Tutorial Lengkap Cohere API: Embeddings, Reranking, dan RAG dengan Python

Cohere adalah platform AI yang menyediakan model bahasa besar (LLM) melalui API yang mudah digunakan. Berbeda dengan penyedia AI lainnya, Cohere memiliki keunggulan khusus pada tiga area utama: text embeddings berkualitas tinggi, reranking untuk meningkatkan relevansi pencarian, dan Retrieval-Augmented Generation (RAG) yang sudah terintegrasi langsung. Tutorial ini akan membahas cara menggunakan Cohere API secara lengkap dengan Python, mulai dari setup dasar hingga membangun sistem RAG yang production-ready.

Mengapa Cohere?

Sebelum masuk ke implementasi, ada beberapa alasan mengapa Cohere layak dipertimbangkan:

Instalasi dan Setup

Instalasi SDK

pip install cohere

Untuk proyek yang lebih lengkap, install juga dependensi tambahan:

pip install cohere numpy scikit-learn pandas chromadb

Mendapatkan API Key

export COHEREAPIKEY="your-api-key-here"

Inisialisasi Client

import cohere
import os

co = cohere.ClientV2(
    apikey=os.environ.get("COHEREAPIKEY")

)

response = co.chat(
    model="command-a-08-2025",
    messages=[
        {
            "role": "user",
            "content": "Jelaskan konsep machine learning dalam 3 kalimat"
        }
    ]
)

print(response.message.content[0].text)

response = co.chat(
    model="command-a-08-2025",
    messages=[
        {
            "role": "system",
            "content": "Kamu adalah asisten AI yang ahli dalam data science. Jawab dalam Bahasa Indonesia dengan gaya yang mudah dipahami."
        },
        {
            "role": "user",
            "content": "Apa perbedaan antara supervised dan unsupervised learning?"
        }
    ]
)

print(response.message.content[0].text)

response = co.chatstream(
    model="command-a-08-2025",
    messages=[
        {
            "role": "user",
            "content": "Tulis panduan singkat tentang feature engineering"
        }
    ]
)

for event in response:
    if event.type == "content-delta":
        print(event.delta.message.content.text, end="")

Structured Output dengan Response Format

Cohere mendukung structured output menggunakan JSON schema:

import json

response = co.chat(
    model="command-a-08-2025",
    messages=[
        {
            "role": "user",
            "content": "Berikan 3 rekomendasi library Python untuk data visualization"
        }
    ],
    responseformat={

        "type": "jsonobject",
        "jsonschema": {

            "type": "object",
            "properties": {
                "recommendations": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "name": {"type": "string"},
                            "usecase": {"type": "string"},
                            "difficulty": {"type": "string", "enum": ["beginner", "intermediate", "advanced"]}
                        },
                        "required": ["name", "usecase", "difficulty"]

                    }
                }
            },
            "required": ["recommendations"]
        }
    }
)

result = json.loads(response.message.content[0].text)
print(json.dumps(result, indent=2))

texts = [
    "Machine learning adalah cabang dari kecerdasan buatan",
    "Deep learning menggunakan neural network berlapis",
    "Natural language processing memproses bahasa manusia",
    "Computer vision memahami gambar dan video",
    "Reinforcement learning belajar dari interaksi dengan lingkungan"
]

response = co.embed(
    texts=texts,
    model="embed-v4.0",
    inputtype="searchdocument",

    embeddingtypes=["float"]
)

embeddings = response.embeddings.float


print(f"Jumlah embeddings: {len(embeddings)}")
print(f"Dimensi per embedding: {len(embeddings[0])}")

Parameter inputtype sangat penting untuk kualitas embedding:

• searchdocument: Untuk teks yang akan dicari (disimpan di database)
• searchquery: Untuk query pencarian dari pengguna
• classification: Untuk task klasifikasi teks
• clustering: Untuk task clustering/pengelompokan

queryembedding = co.embed(
    texts=["Apa itu deep learning?"],
    model="embed-v4.0",
    inputtype="searchquery",

    embeddingtypes=["float"]
)

docembeddings = co.embed(

    texts=texts,
    model="embed-v4.0",
    inputtype="searchdocument",

    embeddingtypes=["float"]
)

Semantic Search dengan Embeddings

import numpy as np

def cosinesimilarity(a, b):

    return np.dot(a, b) / (np.linalg.norm(a)  np.linalg.norm(b))


query = "Bagaimana komputer bisa memahami gambar?"

queryemb = co.embed(
    texts=[query],
    model="embed-v4.0",
    inputtype="searchquery",
    embeddingtypes=["float"]

).embeddings.float[0]

docembs = co.embed(

    texts=texts,
    model="embed-v4.0",
    inputtype="searchdocument",

    embeddingtypes=["float"]
).embeddings.float


similarities = []
for i, docemb in enumerate(docembs):

    sim = cosinesimilarity(queryemb, docemb)
    similarities.append((i, sim, texts[i]))

similarities.sort(key=lambda x: x[1], reverse=True)

print(f"Query: {query}\n")
for idx, sim, text in similarities:
    print(f"  Score: {sim:.4f} | {text}")

multilingualtexts = [
    "Artificial intelligence is transforming industries",
    "Kecerdasan buatan mengubah industri",
    "L'intelligence artificielle transforme les industries",
    "人工知能は産業を変革している",
    "La inteligencia artificial está transformando las industrias"
]

response = co.embed(
    texts=multilingualtexts,
    model="embed-v4.0",
    inputtype="searchdocument",
    embeddingtypes=["float"]

)

embs = response.embeddings.float
for i in range(len(multilingualtexts)):

    for j in range(i + 1, len(multilingualtexts)):
        sim = cosinesimilarity(embs[i], embs[j])

        print(f"'{multilingualtexts[i][:40]}...' <-> '{multilingualtexts[j][:40]}...': {sim:.4f}")

query = "Bagaimana cara meningkatkan performa model machine learning?"

documents = [
    "Hyperparameter tuning adalah proses mencari kombinasi parameter terbaik untuk model ML",
    "Python adalah bahasa pemrograman yang populer untuk data science",
    "Feature engineering dapat meningkatkan akurasi model secara signifikan",
    "Transfer learning memungkinkan penggunaan model pre-trained untuk task baru",
    "Docker digunakan untuk containerization aplikasi",
    "Cross-validation membantu mengevaluasi performa model secara lebih robust",
    "Ensemble methods menggabungkan beberapa model untuk hasil yang lebih baik",
    "Git adalah version control system yang penting untuk developer"
]

response = co.rerank(
    model="rerank-v3.5",
    query=query,
    documents=documents,
    topn=5
)

print(f"Query: {query}\n")
print("Hasil Reranking (Top 5):")
for result in response.results:
    print(f"  Score: {result.relevancescore:.4f} | {documents[result.index]}")

documentswithmetadata = [
    {"title": "Hyperparameter Tuning Guide", "text": "Hyperparameter tuning mencari kombinasi parameter optimal menggunakan grid search, random search, atau Bayesian optimization"},
    {"title": "Feature Engineering Handbook", "text": "Feature engineering menciptakan fitur baru dari data mentah untuk meningkatkan prediksi model"},
    {"title": "Docker Basics", "text": "Docker menyediakan platform containerization untuk menjalankan aplikasi dalam environment terisolasi"},
    {"title": "Ensemble Methods", "text": "Ensemble methods seperti Random Forest dan Gradient Boosting menggabungkan prediksi dari multiple models"}
]

response = co.rerank(
    model="rerank-v3.5",
    query="cara meningkatkan akurasi prediksi",
    documents=[d["text"] for d in documentswithmetadata],

    topn=3
)

print("Dokumen Paling Relevan:")
for result in response.results:
    doc = documentswithmetadata[result.index]
    print(f"\n  Title: {doc['title']}")
    print(f"  Score: {result.relevancescore:.4f}")

    print(f"  Text: {doc['text']}")

import numpy as np

corpus = [
    "Neural networks terdiri dari layer-layer neuron yang saling terhubung",
    "Random Forest adalah ensemble method berbasis decision tree",
    "Gradient descent mengoptimalkan weight model secara iteratif",
    "Batch normalization menstabilkan proses training neural network",
    "Dropout adalah teknik regularisasi untuk mencegah overfitting",
    "Learning rate menentukan seberapa besar update weight pada setiap iterasi",
    "Data augmentation memperbanyak data training dengan transformasi",
    "Backpropagation menghitung gradient error untuk update weight",
    "Convolutional layer mengekstrak fitur spasial dari input gambar",
    "Attention mechanism memungkinkan model fokus pada bagian input yang relevan",
    "Tokenization memecah teks menjadi unit-unit kecil untuk diproses model",
    "Kucing adalah hewan peliharaan yang lucu",
    "Resep nasi goreng membutuhkan nasi, kecap, dan telur",
    "Sepak bola adalah olahraga paling populer di dunia"
]

query = "Bagaimana cara mencegah model overfit?"

corpusembs = co.embed(
    texts=corpus,
    model="embed-v4.0",
    inputtype="searchdocument",
    embeddingtypes=["float"]

).embeddings.float

queryemb = co.embed(

    texts=[query],
    model="embed-v4.0",
    inputtype="searchquery",

    embeddingtypes=["float"]
).embeddings.float[0]


similarities = [cosinesimilarity(queryemb, docemb) for docemb in corpusembs]
topindices = np.argsort(similarities)[-8:][::-1]

candidates = [corpus[i] for i in topindices]

print("Stage 1 - Embedding Search (Top 8):")
for i, idx in enumerate(topindices):

    print(f"  {i+1}. [{similarities[idx]:.4f}] {corpus[idx]}")

rerankresponse = co.rerank(
    model="rerank-v3.5",
    query=query,
    documents=candidates,
    topn=3

)

print(f"\nStage 2 - Reranked (Top 3):")
for result in rerankresponse.results:
    print(f"  Score: {result.relevancescore:.4f} | {candidates[result.index]}")

knowledgebase = [
    {
        "title": "Tentang Perusahaan",
        "text": "PT DataTech Indonesia didirikan pada tahun 2020. Perusahaan bergerak di bidang konsultasi data dan artificial intelligence. Kantor pusat berlokasi di Jakarta Selatan."
    },
    {
        "title": "Layanan Utama",
        "text": "Layanan utama meliputi: Data Engineering, Machine Learning Operations (MLOps), Business Intelligence, dan AI Consulting. Setiap layanan tersedia dalam paket bulanan atau project-based."
    },
    {
        "title": "Tim dan Keahlian",
        "text": "Tim terdiri dari 25 data engineer, 15 ML engineer, dan 10 data analyst. Rata-rata pengalaman tim adalah 5 tahun di industri teknologi."
    },
    {
        "title": "Teknologi yang Digunakan",
        "text": "Stack teknologi meliputi Python, Apache Spark, Airflow, dbt, MLflow, Kubernetes, dan berbagai layanan cloud dari AWS, GCP, dan Azure."
    },
    {
        "title": "Pricing",
        "text": "Paket konsultasi dimulai dari Rp 15 juta per bulan untuk Basic, Rp 35 juta untuk Professional, dan Rp 75 juta untuk Enterprise. Custom pricing tersedia untuk project skala besar."
    }
]

query = "Berapa biaya untuk menggunakan layanan konsultasi?"

doctexts = [doc["text"] for doc in knowledgebase]
docembs = co.embed(

    texts=doctexts,
    model="embed-v4.0",
    inputtype="searchdocument",
    embeddingtypes=["float"]

).embeddings.float

queryemb = co.embed(

    texts=[query],
    model="embed-v4.0",
    inputtype="searchquery",

    embeddingtypes=["float"]
).embeddings.float[0]


similarities = [cosinesimilarity(queryemb, emb) for emb in docembs]
topindices = np.argsort(similarities)[-3:][::-1]

relevantdocs = [knowledgebase[i] for i in topindices]

rerankresponse = co.rerank(

    model="rerank-v3.5",
    query=query,
    documents=[doc["text"] for doc in relevantdocs],
    topn=2

)

contextdocs = []
for result in rerankresponse.results:

    doc = relevantdocs[result.index]
    contextdocs.append(doc)


documentsforrag = [

    {"id": str(i), "data": {"title": doc["title"], "text": doc["text"]}}
    for i, doc in enumerate(contextdocs)
]

response = co.chat(
    model="command-a-08-2025",
    messages=[
        {
            "role": "user",
            "content": query
        }
    ],
    documents=documentsforrag
)

print(f"Query: {query}\n")
print(f"Jawaban: {response.message.content[0].text}")

if response.message.citations:
    print("\nSumber:")
    for citation in response.message.citations:
        print(f"  - {citation}")

import chromadb

chromaclient = chromadb.Client()

collection = chromaclient.createcollection(name="knowledgebase")

documents = [
    "Python adalah bahasa pemrograman yang paling populer untuk data science dan machine learning.",
    "TensorFlow dan PyTorch adalah dua framework deep learning utama yang digunakan di industri.",
    "Pandas menyediakan struktur data DataFrame untuk manipulasi dan analisis data tabular.",
    "Scikit-learn menyediakan implementasi algoritma machine learning klasik yang mudah digunakan.",
    "Apache Spark memungkinkan pemrosesan data besar secara terdistribusi.",
    "MLflow adalah platform open-source untuk mengelola lifecycle machine learning.",
    "Docker container memastikan konsistensi environment antara development dan production.",
    "Kubernetes mengorkestrasikan deployment container pada skala besar.",
    "FastAPI adalah framework Python modern untuk membangun API dengan performa tinggi.",
    "Airflow adalah workflow orchestrator untuk pipeline data dan ML."
]

docembeddings = co.embed(

    texts=documents,
    model="embed-v4.0",
    inputtype="searchdocument",

    embeddingtypes=["float"]
).embeddings.float


collection.add(
    documents=documents,
    embeddings=docembeddings,
    ids=[f"doc{i}" for i in range(len(documents))]

)

def ragquery(query: str, topk: int = 5) -> str:

    queryemb = co.embed(
        texts=[query],
        model="embed-v4.0",
        inputtype="searchquery",
        embeddingtypes=["float"]

    ).embeddings.float[0]

    results = collection.query(
        queryembeddings=[queryemb],
        nresults=topk
    )

    candidatedocs = results["documents"][0]


    rerankresponse = co.rerank(
        model="rerank-v3.5",
        query=query,
        documents=candidatedocs,

        topn=3
    )

    topdocs = [candidatedocs[r.index] for r in rerankresponse.results]

    documentsforrag = [

        {"id": str(i), "data": {"text": doc}}
        for i, doc in enumerate(topdocs)
    ]

    response = co.chat(
        model="command-a-08-2025",
        messages=[
            {
                "role": "system",
                "content": "Jawab pertanyaan berdasarkan konteks dokumen yang diberikan. Jika informasi tidak tersedia di dokumen, katakan bahwa kamu tidak memiliki informasi tersebut."
            },
            {
                "role": "user",
                "content": query
            }
        ],
        documents=documentsforrag
    )

    return response.message.content[0].text

answer = ragquery("Framework apa yang cocok untuk deep learning?")

print(answer)

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "getweather",
            "description": "Mendapatkan informasi cuaca untuk kota tertentu",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "Nama kota"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Unit temperatur"
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculatebmi",

            "description": "Menghitung Body Mass Index",
            "parameters": {
                "type": "object",
                "properties": {
                    "weightkg": {
                        "type": "number",
                        "description": "Berat badan dalam kilogram"
                    },
                    "heightm": {

                        "type": "number",
                        "description": "Tinggi badan dalam meter"
                    }
                },
                "required": ["weightkg", "heightm"]

            }
        }
    }
]

def getweather(city: str, unit: str = "celsius") -> dict:
    weatherdata = {

        "Jakarta": {"temp": 32, "condition": "Cerah berawan", "humidity": 75},
        "Bandung": {"temp": 24, "condition": "Berawan", "humidity": 80},
        "Surabaya": {"temp": 34, "condition": "Cerah", "humidity": 70}
    }
    data = weatherdata.get(city, {"temp": 28, "condition": "Tidak diketahui", "humidity": 65})
    if unit == "fahrenheit":
        data["temp"] = data["temp"]  9/5 + 32
    return {data, "city": city, "unit": unit}


def calculatebmi(weightkg: float, heightm: float) -> dict:

    bmi = weightkg / (heightm  2)

    if bmi < 18.5:
        category = "Underweight"
    elif bmi < 25:
        category = "Normal"
    elif bmi < 30:
        category = "Overweight"
    else:
        category = "Obese"
    return {"bmi": round(bmi, 2), "category": category}

response = co.chat(
    model="command-a-08-2025",
    messages=[
        {"role": "user", "content": "Bagaimana cuaca di Jakarta hari ini?"}
    ],
    tools=tools
)

if response.message.toolcalls:
    toolresults = []

    for toolcall in response.message.toolcalls:

        funcname = toolcall.function.name

        args = json.loads(toolcall.function.arguments)

        if funcname == "getweather":
            result = getweather(args)

        elif funcname == "calculatebmi":

            result = calculatebmi(args)

        toolresults.append({

            "call": toolcall,
            "outputs": [result]
        })

    followup = co.chat(

        model="command-a-08-2025",
        messages=[
            {"role": "user", "content": "Bagaimana cuaca di Jakarta hari ini?"},
            {"role": "assistant", "toolcalls": response.message.toolcalls},

            {"role": "tool", "toolcallid": response.message.toolcalls[0].id, "content": json.dumps(result)}
        ],
        tools=tools
    )
    print(followup.message.content[0].text)

def batchembed(texts: list, batchsize: int = 96) -> list:
    allembeddings = []
    for i in range(0, len(texts), batchsize):

        batch = texts[i:i + batchsize]
        response = co.embed(
            texts=batch,
            model="embed-v4.0",
            inputtype="searchdocument",
            embeddingtypes=["float"]

        )
        allembeddings.extend(response.embeddings.float)

        print(f"Processed batch {i // batchsize + 1}/{(len(texts) - 1) // batchsize + 1}")

    return allembeddings

largecorpus = [f"Dokumen nomor {i} berisi informasi tentang topik {i % 10}" for i in range(500)]

embeddings = batchembed(largecorpus)

print(f"Total embeddings: {len(embeddings)}")

from sklearn.linearmodel import LogisticRegression
from sklearn.modelselection import traintestsplit

from sklearn.metrics import classificationreport

traintexts = [

    "Harga saham BBCA naik 2% hari ini",
    "Inflasi bulan ini tercatat 3.5%",
    "Bank Indonesia menaikkan suku bunga acuan",
    "Revenue perusahaan tumbuh 15% YoY",
    "Timnas Indonesia menang 3-0 melawan Thailand",
    "Liga Premier Inggris memasuki pekan ke-20",
    "Pemain baru bergabung dengan klub sepakbola",
    "Pertandingan final piala dunia sangat seru",
    "Peneliti menemukan obat baru untuk diabetes",
    "Vaksin COVID generasi baru mulai didistribusikan",
    "Rumah sakit menambah kapasitas ICU",
    "Program kesehatan masyarakat diluncurkan pemerintah"
]

trainlabels = [
    "ekonomi", "ekonomi", "ekonomi", "ekonomi",
    "olahraga", "olahraga", "olahraga", "olahraga",
    "kesehatan", "kesehatan", "kesehatan", "kesehatan"
]

trainembs = co.embed(

    texts=traintexts,
    model="embed-v4.0",
    inputtype="classification",

    embeddingtypes=["float"]
).embeddings.float


clf = LogisticRegression(maxiter=1000)
clf.fit(trainembs, trainlabels)

testtexts = [

    "Rupiah menguat terhadap dolar AS",
    "Gol indah dicetak di menit akhir",
    "Pandemi flu burung menjadi perhatian WHO"
]

testembs = co.embed(
    texts=testtexts,

    model="embed-v4.0",
    inputtype="classification",
    embeddingtypes=["float"]

).embeddings.float

predictions = clf.predict(testembs)

for text, pred in zip(testtexts, predictions):
    print(f"  '{text}' -> {pred}")

Clustering Dokumen

from sklearn.cluster import KMeans

documents = [
    "Cara memasak rendang yang autentik",
    "Resep soto betawi dengan santan",
    "Tips membuat nasi goreng yang lezat",
    "Tutorial Python untuk pemula",
    "Belajar machine learning dari nol",
    "Panduan menggunakan Git dan GitHub",
    "Tips menjaga kesehatan jantung",
    "Manfaat olahraga rutin setiap hari",
    "Cara tidur yang berkualitas"
]

embeddings = co.embed(
    texts=documents,
    model="embed-v4.0",
    inputtype="clustering",

    embeddingtypes=["float"]
).embeddings.float


kmeans = KMeans(nclusters=3, randomstate=42, ninit=10)
clusters = kmeans.fitpredict(embeddings)


for clusterid in range(3):
    print(f"\nCluster {clusterid}:")

    for i, doc in enumerate(documents):
        if clusters[i] == clusterid:
            print(f"  - {doc}")

Best Practices

1. Pilih Model yang Tepat

| Use Case | Model | Catatan |

|-----------|-------|---------|

| Text Generation | command-a-08-2025 | Model terbaru dan paling capable |

| Embeddings | embed-v4.0 | Unggul di benchmark MTEB |

| Reranking | rerank-v3.5 | Mendukung multi-aspect dan long documents |

| Lightweight Generation | command-r | Lebih cepat, biaya lebih rendah |

2. Optimasi Embedding

• Selalu gunakan inputtype yang sesuai dengan use case
• Proses dalam batch untuk volume besar (maksimal 96 teks per request)
• Cache embeddings untuk dokumen yang jarang berubah
• Gunakan embeddingtypes=["float"] untuk presisi penuh

3. Strategi Reranking yang Efektif

• Gunakan two-stage retrieval: embedding untuk recall, reranking untuk precision
• Set topn sesuai kebutuhan untuk menghemat latency
• Reranking paling efektif pada 50-200 kandidat dokumen
• Untuk dataset kecil (di bawah 50 dokumen), reranking langsung tanpa embedding sudah cukup

def productionrag(query: str, collection, topk: int = 10, reranktop: int = 3) -> dict:
    queryemb = co.embed(

        texts=[query],
        model="embed-v4.0",
        inputtype="searchquery",

        embeddingtypes=["float"]
    ).embeddings.float[0]


    results = collection.query(
        queryembeddings=[queryemb],

        nresults=topk

    )

    if not results["documents"][0]:
        return {"answer": "Tidak ditemukan dokumen yang relevan.", "sources": []}

    candidatedocs = results["documents"][0]

    rerankresponse = co.rerank(

        model="rerank-v3.5",
        query=query,
        documents=candidatedocs,
        topn=reranktop
    )

    filtereddocs = [

        candidatedocs[r.index]
        for r in rerankresponse.results

        if r.relevancescore > 0.3
    ]

    if not filtereddocs:

        return {"answer": "Tidak ditemukan dokumen yang cukup relevan.", "sources": []}

    documentsforrag = [

        {"id": str(i), "data": {"text": doc}}
        for i, doc in enumerate(filtereddocs)
    ]

    response = co.chat(
        model="command-a-08-2025",
        messages=[
            {
                "role": "system",
                "content": "Jawab berdasarkan dokumen yang tersedia. Jika tidak ada informasi yang relevan, katakan dengan jujur."
            },
            {"role": "user", "content": query}
        ],
        documents=documentsforrag,
        temperature=0.3
    )

    return {
        "answer": response.message.content[0].text,
        "sources": filtereddocs,

        "citations": response.message.citations if response.message.citations else []
    }

import cohere
import time

def safeapicall(func, maxretries=3, basedelay=1):

    for attempt in range(maxretries):
        try:
            return func()
        except cohere.TooManyRequestsError:
            delay = basedelay  (2  attempt)

            print(f"Rate limited. Retrying in {delay}s...")
            time.sleep(delay)
        except cohere.BadRequestError as e:
            print(f"Bad request: {e}")
            raise
        except Exception as e:
            if attempt == maxretries - 1:
                raise
            print(f"Error: {e}. Retrying...")
            time.sleep(basedelay)


result = safeapicall(

    lambda: co.embed(
        texts=["test"],
        model="embed-v4.0",
        inputtype="searchquery",

        embeddingtypes=["float"]
    )
)

Pendekatan two-stage retrieval (embedding + reranking) yang ditunjukkan di tutorial ini adalah pola yang sudah terbukti efektif di production dan menjadi standar industri untuk sistem pencarian berbasis AI. Dengan menguasai Cohere API, Anda memiliki fondasi yang kuat untuk membangun berbagai aplikasi AI mulai dari chatbot, sistem pencarian, hingga knowledge management platform.

Untuk langkah selanjutnya, eksplorasi integrasi Cohere dengan vector database seperti Qdrant atau Weaviate untuk membangun sistem RAG yang lebih scalable, dan pertimbangkan penggunaan fine-tuning untuk menyesuaikan model dengan domain spesifik Anda.