Tutorial Jina AI: Embeddings, Reranker, dan Reader API untuk RAG Pipeline

# Tutorial Lengkap Jina AI: Embeddings, Reranker, dan Reader API untuk RAG Pipeline Jina AI telah menjadi salah satu penyedia layanan embedding dan reranking terpopuler di ekosistem AI modern. Dengan...

By Ruby Abdullah · · tutorial
Jina AIEmbeddingsRAGRerankerSemantic Search

Tutorial Lengkap Jina AI: Embeddings, Reranker, dan Reader API untuk RAG Pipeline

Jina AI telah menjadi salah satu penyedia layanan embedding dan reranking terpopuler di ekosistem AI modern. Dengan model jina-embeddings-v3 yang mendukung 89 bahasa dan Jina Reranker v2 yang mampu memproses dokumen hingga 1 juta token, Jina AI menawarkan solusi end-to-end untuk membangun pipeline Retrieval-Augmented Generation (RAG) yang berkualitas tinggi. Dalam tutorial ini, kita akan membahas secara mendalam cara menggunakan Jina AI Embeddings, Reranker, dan Reader API untuk membangun sistem pencarian semantik yang akurat dan efisien.

Mengapa Jina AI?

Sebelum masuk ke implementasi, mari kita pahami mengapa Jina AI layak dipertimbangkan:

  • Multilingual Support: jina-embeddings-v3 mendukung 89 bahasa termasuk Bahasa Indonesia, menjadikannya pilihan ideal untuk aplikasi multibahasa.
  • Late Chunking: Teknologi proprietary yang mempertahankan konteks antar chunk, menghasilkan embedding yang lebih akurat.
  • Task-Specific LoRA Adapters: Satu model bisa dioptimalkan untuk berbagai task (retrieval, classification, text matching) tanpa perlu deploy model terpisah.
  • Matryoshka Representation Learning: Dimensi embedding bisa dikurangi tanpa kehilangan performa signifikan, menghemat storage dan mempercepat pencarian.
  • Reader API: Mengekstrak konten bersih dari URL manapun, sangat berguna untuk web scraping dalam pipeline RAG.
  • Instalasi dan Setup

    Mendapatkan API Key

    Pertama, daftar di Jina AI dan dapatkan API key Anda. Jina menyediakan free tier yang cukup generous untuk development dan testing.

    Instalasi Dependencies

    pip install requests numpy python-dotenv
    

    Untuk integrasi dengan framework populer:

    pip install langchain-community llama-index jina
    

    Konfigurasi Environment

    Buat file .env di root project Anda:

    JINAAPIKEY=jinaxxxxxxxxxxxxxxxxxxxx
    

    Setup konfigurasi dasar:

    import os
    

    import requests

    import numpy as np

    from dotenv import loaddotenv

    loaddotenv()

    JINAAPIKEY = os.getenv("JINAAPIKEY")

    HEADERS = {

    "Authorization": f"Bearer {JINAAPIKEY}",

    "Content-Type": "application/json",

    "Accept": "application/json"

    }

    Jina Embeddings API

    Basic Embedding Generation

    Jina Embeddings API memungkinkan Anda mengubah teks menjadi vektor numerik yang merepresentasikan makna semantik. Berikut cara dasar menggunakannya:

    def getembeddings(texts, model="jina-embeddings-v3", task="retrieval.passage"):
    

    """Generate embeddings menggunakan Jina AI API."""

    url = "https://api.jina.ai/v1/embeddings"

    payload = {

    "model": model,

    "input": texts,

    "task": task,

    "dimensions": 1024

    }

    response = requests.post(url, json=payload, headers=HEADERS)

    response.raiseforstatus()

    data = response.json()

    embeddings = [item["embedding"] for item in data["data"]]

    return embeddings

    Contoh penggunaan

    documents = [

    "Machine learning adalah cabang dari artificial intelligence yang fokus pada pembelajaran dari data.",

    "Deep learning menggunakan neural network dengan banyak layer untuk memproses data kompleks.",

    "Natural language processing memungkinkan komputer memahami dan menghasilkan bahasa manusia.",

    "Computer vision adalah bidang AI yang memungkinkan komputer menginterpretasi gambar dan video."

    ]

    embeddings = getembeddings(documents)

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

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

    Task-Specific Embeddings

    Salah satu fitur unggulan jina-embeddings-v3 adalah kemampuan menggunakan LoRA adapter berbeda untuk task yang berbeda. Ini penting karena embedding yang optimal untuk retrieval berbeda dengan yang optimal untuk classification:

    # Untuk dokumen yang akan disimpan di database vektor
    

    passageembeddings = getembeddings(

    texts=documents,

    task="retrieval.passage"

    )

    Untuk query pencarian pengguna

    query = "Bagaimana cara komputer memahami bahasa manusia?"

    queryembedding = getembeddings(

    texts=[query],

    task="retrieval.query"

    )

    Untuk klasifikasi teks

    classificationembeddings = getembeddings(

    texts=documents,

    task="classification"

    )

    Untuk text matching / similarity

    matchingembeddings = getembeddings(

    texts=documents,

    task="text-matching"

    )

    Untuk separation / clustering

    separationembeddings = getembeddings(

    texts=documents,

    task="separation"

    )

    Setelah mendapatkan embeddings, kita bisa melakukan pencarian semantik menggunakan cosine similarity:

    def cosinesimilarity(vec1, vec2):
    

    """Hitung cosine similarity antara dua vektor."""

    vec1 = np.array(vec1)

    vec2 = np.array(vec2)

    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) np.linalg.norm(vec2))

    def semanticsearch(query, documents, docembeddings, topk=3):

    """Lakukan pencarian semantik pada kumpulan dokumen."""

    # Generate query embedding dengan task retrieval.query

    queryemb = getembeddings([query], task="retrieval.query")[0]

    # Hitung similarity dengan setiap dokumen

    scores = []

    for i, docemb in enumerate(docembeddings):

    score = cosinesimilarity(queryemb, docemb)

    scores.append((i, score, documents[i]))

    # Sort berdasarkan score tertinggi

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

    return scores[:topk]

    Contoh pencarian

    query = "Bagaimana AI bisa melihat dan mengenali objek?"

    results = semanticsearch(query, documents, embeddings)

    print(f"Query: {query}\n")

    for rank, (idx, score, doc) in enumerate(results, 1):

    print(f"{rank}. [Score: {score:.4f}] {doc}")

    Matryoshka Dimensions

    Jina embeddings mendukung Matryoshka Representation Learning, yang memungkinkan Anda mengurangi dimensi embedding tanpa pelatihan ulang:

    # Embedding dengan dimensi penuh (1024)
    

    fullembeddings = getembeddings(documents, dimensions=1024)

    Embedding dengan dimensi dikurangi (512) - lebih cepat, hemat storage

    reducedembeddings = getembeddings(documents, dimensions=512)

    Embedding dengan dimensi minimal (256) - paling hemat

    minimalembeddings = getembeddings(documents, dimensions=256)

    def getembeddings(texts, model="jina-embeddings-v3", task="retrieval.passage", dimensions=1024):

    """Generate embeddings dengan kontrol dimensi."""

    url = "https://api.jina.ai/v1/embeddings"

    payload = {

    "model": model,

    "input": texts,

    "task": task,

    "dimensions": dimensions

    }

    response = requests.post(url, json=payload, headers=HEADERS)

    response.raiseforstatus()

    data = response.json()

    return [item["embedding"] for item in data["data"]]

    Jina Reranker API

    Reranking adalah langkah kritis dalam pipeline RAG. Setelah retrieval awal menggunakan embedding similarity, reranker mengevaluasi ulang relevansi setiap dokumen terhadap query menggunakan cross-encoder yang lebih akurat:

    Basic Reranking

    def rerankdocuments(query, documents, model="jina-reranker-v2-base-multilingual", topn=5):
    

    """Rerank dokumen berdasarkan relevansi terhadap query."""

    url = "https://api.jina.ai/v1/rerank"

    payload = {

    "model": model,

    "query": query,

    "documents": documents,

    "topn": topn,

    "returndocuments": True

    }

    response = requests.post(url, json=payload, headers=HEADERS)

    response.raiseforstatus()

    return response.json()["results"]

    Contoh reranking

    query = "Bagaimana cara deploy model machine learning ke production?"

    candidatedocs = [

    "Docker container memudahkan packaging aplikasi dengan semua dependensinya.",

    "MLflow menyediakan platform untuk mengelola lifecycle model ML termasuk deployment.",

    "Python adalah bahasa pemrograman yang populer untuk data science.",

    "Kubernetes dapat digunakan untuk orchestration container ML model di production.",

    "TensorFlow Serving memungkinkan serving model ML melalui REST atau gRPC API.",

    "Git adalah version control system yang digunakan untuk tracking perubahan kode.",

    "BentoML menyederhanakan proses packaging dan deployment model ML.",

    "Pandas adalah library Python untuk manipulasi dan analisis data."

    ]

    results = rerankdocuments(query, candidatedocs)

    print(f"Query: {query}\n")

    print("Hasil Reranking:")

    for result in results:

    score = result["relevancescore"]

    text = result["document"]["text"]

    idx = result["index"]

    print(f" [{score:.4f}] (idx:{idx}) {text}")

    Reranking dengan Metadata

    Anda juga bisa menyertakan metadata atau judul dokumen untuk meningkatkan akurasi reranking:

    def rerankwithmetadata(query, documentswithtitles, topn=5):
    

    """Rerank dokumen yang memiliki judul/metadata."""

    url = "https://api.jina.ai/v1/rerank"

    # Format dokumen dengan judul

    formatteddocs = []

    for doc in documentswithtitles:

    formatteddocs.append(f"{doc['title']}: {doc['content']}")

    payload = {

    "model": "jina-reranker-v2-base-multilingual",

    "query": query,

    "documents": formatteddocs,

    "topn": topn,

    "returndocuments": True

    }

    response = requests.post(url, json=payload, headers=HEADERS)

    response.raiseforstatus()

    return response.json()["results"]

    Contoh dengan metadata

    docswithtitles = [

    {"title": "MLOps Best Practices", "content": "Continuous integration dan delivery untuk model ML memastikan kualitas dan reliabilitas."},

    {"title": "Data Preprocessing", "content": "Membersihkan dan mentransformasi data mentah menjadi format yang siap untuk training."},

    {"title": "Model Serving", "content": "Deploy model ke production menggunakan TensorFlow Serving atau Triton Inference Server."},

    {"title": "Feature Engineering", "content": "Membuat fitur baru dari data mentah untuk meningkatkan performa model."}

    ]

    results = rerankwithmetadata("cara deploy model ML", docswithtitles)

    for r in results:

    print(f"[{r['relevancescore']:.4f}] {r['document']['text']}")

    Jina Reader API

    Jina Reader API memungkinkan Anda mengekstrak konten bersih dari halaman web manapun, sangat berguna untuk membangun knowledge base dalam pipeline RAG:

    Basic URL Reading

    def readurl(url):
    

    """Ekstrak konten bersih dari URL menggunakan Jina Reader API."""

    readerurl = f"https://r.jina.ai/{url}"

    headers = {

    "Authorization": f"Bearer {JINAAPIKEY}",

    "Accept": "application/json",

    "X-Return-Format": "markdown"

    }

    response = requests.get(readerurl, headers=headers)

    response.raiseforstatus()

    return response.json()

    Contoh membaca halaman web

    result = readurl("https://en.wikipedia.org/wiki/Machinelearning")

    print(f"Title: {result.get('title', 'N/A')}")

    print(f"Content length: {len(result.get('content', ''))}")

    print(f"Content preview: {result.get('content', '')[:500]}")

    Batch URL Reading

    def readmultipleurls(urls):
    

    """Baca konten dari multiple URLs."""

    results = []

    for url in urls:

    try:

    content = readurl(url)

    results.append({

    "url": url,

    "title": content.get("title", ""),

    "content": content.get("content", ""),

    "status": "success"

    })

    except Exception as e:

    results.append({

    "url": url,

    "title": "",

    "content": "",

    "status": f"error: {str(e)}"

    })

    return results

    Contoh batch reading

    urls = [

    "https://pytorch.org/tutorials/beginner/basics/intro.html",

    "https://scikit-learn.org/stable/gettingstarted.html"

    ]

    contents = readmultipleurls(urls)

    for c in contents:

    print(f"[{c['status']}] {c['url']} - {c['title']}")

    Search API

    Jina juga menyediakan Search API yang menggabungkan web search dengan content extraction:

    def jinasearch(query, numresults=5):
    

    """Cari dan ekstrak konten dari web menggunakan Jina Search API."""

    url = f"https://s.jina.ai/{query}"

    headers = {

    "Authorization": f"Bearer {JINAAPIKEY}",

    "Accept": "application/json",

    "X-Retain-Images": "none"

    }

    response = requests.get(url, headers=headers)

    response.raiseforstatus()

    return response.json()

    Contoh pencarian

    results = jinasearch("tutorial deploy machine learning model production 2026")

    for item in results.get("data", []):

    print(f"Title: {item.get('title', 'N/A')}")

    print(f"URL: {item.get('url', 'N/A')}")

    print(f"Content: {item.get('content', '')[:200]}...")

    print()

    Membangun RAG Pipeline Lengkap dengan Jina AI

    Sekarang mari kita gabungkan semua komponen Jina AI untuk membangun pipeline RAG yang lengkap:

    import json
    

    from typing import List, Dict

    class JinaRAGPipeline:

    """RAG Pipeline menggunakan Jina AI untuk embedding, reranking, dan reading."""

    def init(self, apikey: str):

    self.apikey = apikey

    self.headers = {

    "Authorization": f"Bearer {apikey}",

    "Content-Type": "application/json",

    "Accept": "application/json"

    }

    self.knowledgebase = []

    self.kbembeddings = []

    def ingesturls(self, urls: List[str]) -> int:

    """Ingest konten dari URLs ke knowledge base."""

    for url in urls:

    try:

    readerurl = f"https://r.jina.ai/{url}"

    headers = {self.headers, "X-Return-Format": "markdown"}

    response = requests.get(readerurl, headers=headers)

    response.raiseforstatus()

    data = response.json()

    content = data.get("content", "")

    chunks = self.chunktext(content, chunksize=500, overlap=50)

    for chunk in chunks:

    self.knowledgebase.append({

    "source": url,

    "title": data.get("title", ""),

    "content": chunk

    })

    except Exception as e:

    print(f"Error ingesting {url}: {e}")

    # Generate embeddings untuk semua chunks

    texts = [doc["content"] for doc in self.knowledgebase]

    if texts:

    self.kbembeddings = self.getembeddings(texts, task="retrieval.passage")

    return len(self.knowledgebase)

    def ingesttexts(self, texts: List[Dict[str, str]]) -> int:

    """Ingest teks langsung ke knowledge base.

    Args:

    texts: List of dicts dengan keys 'title' dan 'content'

    """

    for text in texts:

    chunks = self.chunktext(text["content"], chunksize=500, overlap=50)

    for chunk in chunks:

    self.knowledgebase.append({

    "source": "directinput",

    "title": text.get("title", ""),

    "content": chunk

    })

    alltexts = [doc["content"] for doc in self.knowledgebase]

    if alltexts:

    self.kbembeddings = self.getembeddings(alltexts, task="retrieval.passage")

    return len(self.knowledgebase)

    def query(self, question: str, topk: int = 10, topn: int = 3) -> List[Dict]:

    """Query RAG pipeline: embed -> retrieve -> rerank."""

    # Step 1: Generate query embedding

    queryemb = self.getembeddings([question], task="retrieval.query")[0]

    # Step 2: Retrieve top-k candidates via cosine similarity

    scores = []

    for i, docemb in enumerate(self.kbembeddings):

    score = self.cosinesimilarity(queryemb, docemb)

    scores.append((i, score))

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

    candidates = scores[:topk]

    # Step 3: Rerank candidates

    candidatetexts = [self.knowledgebase[idx]["content"] for idx, in candidates]

    reranked = self.rerank(question, candidatetexts, topn=topn)

    # Step 4: Return results dengan metadata

    results = []

    for r in reranked:

    originalidx = candidates[r["index"]][0]

    doc = self.knowledgebase[originalidx]

    results.append({

    "content": doc["content"],

    "title": doc["title"],

    "source": doc["source"],

    "embeddingscore": candidates[r["index"]][1],

    "rerankscore": r["relevancescore"]

    })

    return results

    def getembeddings(self, texts, task="retrieval.passage", dimensions=1024):

    url = "https://api.jina.ai/v1/embeddings"

    payload = {

    "model": "jina-embeddings-v3",

    "input": texts,

    "task": task,

    "dimensions": dimensions

    }

    response = requests.post(url, json=payload, headers=self.headers)

    response.raiseforstatus()

    return [item["embedding"] for item in response.json()["data"]]

    def rerank(self, query, documents, topn=5):

    url = "https://api.jina.ai/v1/rerank"

    payload = {

    "model": "jina-reranker-v2-base-multilingual",

    "query": query,

    "documents": documents,

    "topn": topn,

    "returndocuments": True

    }

    response = requests.post(url, json=payload, headers=self.headers)

    response.raiseforstatus()

    return response.json()["results"]

    def chunktext(self, text, chunksize=500, overlap=50):

    words = text.split()

    chunks = []

    for i in range(0, len(words), chunksize - overlap):

    chunk = " ".join(words[i:i + chunksize])

    if chunk.strip():

    chunks.append(chunk)

    return chunks

    @staticmethod

    def cosinesimilarity(vec1, vec2):

    v1, v2 = np.array(vec1), np.array(vec2)

    return float(np.dot(v1, v2) / (np.linalg.norm(v1) np.linalg.norm(v2)))

    Penggunaan RAG Pipeline

    rag = JinaRAGPipeline(apikey=JINAAPIKEY)

    Ingest dokumen

    documents = [

    {"title": "MLOps Fundamentals", "content": "MLOps adalah praktik yang menggabungkan Machine Learning, DevOps, dan Data Engineering untuk mengotomatisasi dan menstandardisasi lifecycle model ML. Komponen utama MLOps meliputi version control untuk model dan data, CI/CD pipeline untuk training dan deployment, monitoring model di production, dan feature store untuk manajemen fitur."},

    {"title": "Model Deployment Strategies", "content": "Ada beberapa strategi deployment model ML: Blue-Green deployment memungkinkan switching antara dua versi model. Canary deployment merilis model baru ke sebagian kecil traffic terlebih dahulu. Shadow deployment menjalankan model baru secara paralel tanpa mempengaruhi response ke user. A/B testing membandingkan performa dua model secara langsung."},

    {"title": "Feature Store", "content": "Feature store adalah sistem penyimpanan terpusat untuk fitur ML yang memastikan konsistensi antara training dan serving. Feature store populer termasuk Feast, Tecton, dan Hopsworks. Manfaat utamanya adalah menghindari training-serving skew, memungkinkan feature reuse, dan mempercepat development model baru."}

    ]

    count = rag.ingesttexts(documents)

    print(f"Ingested {count} chunks")

    Query

    results = rag.query("Bagaimana cara deploy model ML dengan aman?")

    for i, r in enumerate(results, 1):

    print(f"\n--- Result {i} ---")

    print(f"Title: {r['title']}")

    print(f"Rerank Score: {r['rerankscore']:.4f}")

    print(f"Content: {r['content'][:200]}...")

    Integrasi dengan LangChain

    Jina AI terintegrasi dengan baik dengan framework LangChain:

    from langchaincommunity.embeddings import JinaEmbeddings
    

    from langchaincommunity.documentloaders import WebBaseLoader

    from langchain.textsplitter import RecursiveCharacterTextSplitter

    from langchaincommunity.vectorstores import FAISS

    Setup Jina Embeddings

    embeddings = JinaEmbeddings(

    jinaapikey=JINAAPIKEY,

    modelname="jina-embeddings-v3"

    )

    Load dan chunk dokumen

    textsplitter = RecursiveCharacterTextSplitter(

    chunksize=500,

    chunkoverlap=50

    )

    texts = [

    "Machine learning pipeline terdiri dari data collection, preprocessing, feature engineering, model training, evaluation, dan deployment.",

    "Monitoring model di production penting untuk mendeteksi data drift, concept drift, dan degradasi performa model seiring waktu."

    ]

    Buat vector store

    vectorstore = FAISS.fromtexts(texts, embeddings)

    Semantic search

    results = vectorstore.similaritysearchwithscore(

    "Bagaimana mendeteksi permasalahan model di production?",

    k=3

    )

    for doc, score in results:

    print(f"[Score: {score:.4f}] {doc.pagecontent}")

    Integrasi dengan LlamaIndex

    from llamaindex.core import VectorStoreIndex, Document, Settings
    

    from llamaindex.embeddings.jinaai import JinaEmbedding

    Setup Jina Embedding

    Settings.embedmodel = JinaEmbedding(

    apikey=JINAAPIKEY,

    model="jina-embeddings-v3"

    )

    Buat dokumen

    documents = [

    Document(text="Feature engineering adalah proses membuat variabel baru dari data mentah untuk meningkatkan performa model prediktif."),

    Document(text="Hyperparameter tuning menggunakan teknik seperti Grid Search, Random Search, atau Bayesian Optimization untuk menemukan konfigurasi optimal."),

    Document(text="Cross-validation membantu mengevaluasi generalisasi model dengan membagi data menjadi beberapa fold untuk training dan testing.")

    ]

    Bangun index

    index = VectorStoreIndex.fromdocuments(documents)

    Query

    queryengine = index.asqueryengine()

    response = queryengine.query("Bagaimana cara meningkatkan performa model?")

    print(response)

    Best Practices

    1. Pilih Task yang Tepat untuk Embeddings

    Menggunakan task yang tepat sangat mempengaruhi kualitas hasil:

    | Task | Kapan Digunakan |

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

    | retrieval.query | Untuk query/pertanyaan pengguna |

    | retrieval.passage | Untuk dokumen yang akan dicari |

    | text-matching | Untuk mencocokkan dua teks serupa |

    | classification | Untuk klasifikasi teks |

    | separation | Untuk clustering/pengelompokan |

    2. Optimalkan Dimensi Embedding

    # Production dengan kebutuhan akurasi tinggi
    

    highaccuracy = getembeddings(texts, dimensions=1024)

    Balance antara akurasi dan kecepatan

    balanced = getembeddings(texts, dimensions=512)

    Prototype atau dataset sangat besar

    fastprototype = getembeddings(texts, dimensions=256)

    3. Gunakan Reranker Setelah Initial Retrieval

    Selalu gunakan two-stage retrieval:

  • Stage 1: Retrieve 20-50 kandidat menggunakan embedding similarity (cepat)
  • Stage 2: Rerank top kandidat menggunakan cross-encoder (lebih akurat)
  • # BAIK: Two-stage retrieval
    

    initialcandidates = vectorsearch(query, topk=30) # Cepat

    finalresults = rerank(query, initialcandidates, topn=5) # Akurat

    KURANG OPTIMAL: Hanya embedding search

    results = vectorsearch(query, topk=5) # Mungkin miss dokumen relevan

    4. Batching untuk Efisiensi

    # BAIK: Batch processing
    

    allembeddings = getembeddings(alldocuments) # Satu API call

    KURANG OPTIMAL: Satu per satu

    for doc in alldocuments:

    emb = getembeddings([doc]) # Banyak API calls

    5. Caching Embeddings

    import hashlib
    

    import json

    class EmbeddingCache:

    def init(self, cachefile="embeddingcache.json"):

    self.cachefile = cachefile

    try:

    with open(cachefile, "r") as f:

    self.cache = json.load(f)

    except FileNotFoundError:

    self.cache = {}

    def getorcompute(self, text, computefn):

    key = hashlib.md5(text.encode()).hexdigest()

    if key not in self.cache:

    self.cache[key] = computefn(text)

    self.save()

    return self.cache[key]

    def save(self):

    with open(self.cachefile, "w") as f:

    json.dump(self.cache, f)

    cache = EmbeddingCache()

    embedding = cache.getorcompute(

    "teks yang akan di-embed",

    lambda t: getembeddings([t])[0]

    )

    6. Error Handling dan Rate Limiting

    import time
    
    

    def getembeddingswithretry(texts, maxretries=3, backoff=2):

    """Get embeddings dengan retry logic."""

    for attempt in range(maxretries):

    try:

    return getembeddings(texts)

    except requests.exceptions.HTTPError as e:

    if e.response.statuscode == 429: # Rate limited

    waittime = backoff attempt

    print(f"Rate limited. Waiting {waittime}s...")

    time.sleep(waittime)

    elif e.response.statuscode >= 500: # Server error

    waittime = backoff attempt

    print(f"Server error. Retrying in {waittime}s...")

    time.sleep(waittime)

    else:

    raise

    raise Exception(f"Failed after {max_retries} retries")

    Perbandingan Model Jina

    | Model | Dimensi | Bahasa | Context Length | Use Case |

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

    | jina-embeddings-v3 | 1024 (adjustable) | 89 bahasa | 8192 tokens | General purpose, multilingual |

    | jina-embeddings-v2-base-en | 768 | English | 8192 tokens | English-only, cost-effective |

    | jina-reranker-v2-base-multilingual | N/A | Multilingual | 1M tokens | Reranking dokumen panjang |

    | jina-colbert-v2 | 128 per token | Multilingual | 8192 tokens | Late interaction retrieval |

    Kesimpulan

    Jina AI menyediakan toolkit yang komprehensif untuk membangun pipeline RAG berkualitas tinggi. Dengan menggabungkan embeddings, reranker, dan reader API, Anda dapat membangun sistem pencarian semantik yang akurat dan efisien. Beberapa poin penting yang perlu diingat:

  • Gunakan task-specific embeddings untuk hasil optimal pada setiap use case.
  • Terapkan two-stage retrieval (embedding + reranker) untuk akurasi maksimal.
  • Manfaatkan Matryoshka dimensions untuk mengoptimalkan trade-off antara akurasi dan performa.
  • Gunakan Reader API untuk mengekstrak konten bersih dari web sebagai sumber knowledge base.
  • Integrasikan dengan framework seperti LangChain atau LlamaIndex untuk mempercepat development.
  • Dengan fondasi yang solid dari Jina AI, Anda bisa membangun aplikasi RAG yang siap production dan mampu menangani kebutuhan pencarian semantik dalam berbagai bahasa termasuk Bahasa Indonesia.

    Artikel Terkait

    Tutorial Lengkap txtai: Database Embeddings All-in-One untuk Semantic Search dan LLM Workflows

    Tutorial Lengkap txtai: Database Embeddings All-in-One untuk Semantic Search dan LLM Workflows txtai adalah framework Py...

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

    Tutorial Lengkap Cohere API: Embeddings, Reranking, dan RAG dengan Python Cohere adalah platform AI yang menyediakan mod...

    FastEmbed: Bikin Embedding Cepat dan Ringan Tanpa Torch dari Qdrant

    FastEmbed: Bikin Embedding Cepat dan Ringan Tanpa Torch dari Qdrant Halo temen-temen, balik lagi sama aku Ruby Abdullah....

    Tutorial Lengkap Pinecone: Vector Database untuk AI dan Semantic Search

    Tutorial Lengkap Pinecone: Vector Database untuk AI dan Semantic Search Pinecone adalah managed vector database yang dir...