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:
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"
)
Cosine Similarity Search
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,
"top
n": topn,
"return
documents": 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
formatted
docs = []
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."""
reader
url = 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 = read
url(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 {JINA
APIKEY}",
"Accept": "application/json",
"X-Retain-Images": "none"
}
response = requests.get(url, headers=headers)
response.raise
forstatus()
return response.json()
Contoh pencarian
results = jina
search("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 langchain
community.documentloaders import WebBaseLoader
from langchain.text
splitter 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 llama
index.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:
# 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:
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.