Tutorial Lengkap Tavily: AI Search API untuk RAG dan AI Agents
Tavily adalah search API yang dirancang khusus untuk aplikasi AI, Large Language Models (LLM), dan Retrieval-Augmented Generation (RAG). Berbeda dengan search API tradisional seperti Google Custom Search atau Bing API yang mengembalikan daftar URL, Tavily mengoptimalkan hasil pencarian untuk dikonsumsi langsung oleh AI — memberikan konten yang sudah diekstrak, dirangkum, dan siap digunakan sebagai konteks LLM.
Dalam tutorial ini, kita akan mempelajari cara menggunakan Tavily mulai dari instalasi, penggunaan dasar, integrasi dengan LangChain dan LlamaIndex, hingga membangun aplikasi RAG yang powerful menggunakan Tavily sebagai sumber pengetahuan real-time.
Mengapa Tavily?
Ketika membangun aplikasi AI yang membutuhkan informasi terkini dari internet, developer menghadapi beberapa tantangan:
Tavily menyelesaikan semua masalah ini dengan menyediakan:
- Hasil pencarian yang sudah diekstrak dan dibersihkan
- Konten yang dioptimalkan untuk konsumsi LLM
- Support untuk berbagai search depth (basic dan advanced)
- Integrasi native dengan framework AI populer
- Pricing yang terjangkau untuk penggunaan production
Instalasi
Python SDK
pip install tavily-python
Node.js SDK
npm install @tavily/core
Mendapatkan API Key
export TAVILYAPIKEY="tvly-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
Atau simpan dalam file .env:
TAVILYAPIKEY=tvly-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Tavily menyediakan free tier dengan 1000 API calls per bulan, cukup untuk development dan prototyping.
Penggunaan Dasar
Python — Simple Search
from tavily import TavilyClient
client = TavilyClient(apikey="tvly-YOURAPIKEY")
response = client.search("Apa itu Retrieval Augmented Generation?")
for result in response["results"]:
print(f"Title: {result['title']}")
print(f"URL: {result['url']}")
print(f"Content: {result['content'][:200]}...")
print("---")
Response Structure
{
"query": "Apa itu Retrieval Augmented Generation?",
"followupquestions": None,
"answer": None,
"images": [],
"results": [
{
"title": "What is RAG? - Retrieval-Augmented Generation Explained",
"url": "https://example.com/rag-explained",
"content": "Retrieval-Augmented Generation (RAG) is...",
"score": 0.98,
"rawcontent": None
}
],
"responsetime": 1.23
}
Node.js — Simple Search
const { tavily } = require("@tavily/core");
const client = tavily({ apiKey: "tvly-YOURAPIKEY" });
async function search() {
const response = await client.search("Latest developments in AI agents 2026");
response.results.forEach(result => {
console.log(Title: ${result.title});
console.log(URL: ${result.url});
console.log(Score: ${result.score});
console.log("---");
});
}
search();
Search dengan Parameter Lanjutan
from tavily import TavilyClient
client = TavilyClient(apikey="tvly-YOURAPIKEY")
response = client.search(
query="machine learning model deployment best practices",
searchdepth="advanced", # "basic" atau "advanced"
topic="general", # "general" atau "news"
maxresults=10, # jumlah hasil (default: 5)
includedomains=["arxiv.org", "huggingface.co"], # filter domain
excludedomains=["pinterest.com"], # exclude domain
includeanswer=True, # sertakan jawaban AI
includerawcontent=True, # sertakan raw HTML content
includeimages=True # sertakan gambar relevan
)
if response.get("answer"):
print(f"AI Answer: {response['answer']}\n")
for result in response["results"]:
print(f"[{result['score']:.2f}] {result['title']}")
print(f" URL: {result['url']}")
print(f" Content: {result['content'][:150]}...")
print()
Search Depth: Basic vs Advanced
Tavily menawarkan dua level kedalaman pencarian:
Basic Search
- Lebih cepat (rata-rata 1-2 detik)
- Cocok untuk pertanyaan umum dan fakta sederhana
- Biaya lebih rendah per query
- Menggunakan 1 API credit
Advanced Search
- Lebih mendalam (rata-rata 3-5 detik)
- Melakukan multi-step search dan analisis
- Mengekstrak konten lebih detail dari setiap halaman
- Menggunakan 2 API credits
- Ideal untuk research dan pertanyaan kompleks
basicresult = client.search("Python release date", searchdepth="basic")
advancedresult = client.search(
"Perbandingan arsitektur transformer vs mamba untuk sequence modeling",
searchdepth="advanced"
)
Context Search untuk RAG
Fitur getsearchcontext dirancang khusus untuk pipeline RAG. Method ini mengembalikan string yang sudah dioptimalkan untuk dimasukkan langsung sebagai konteks LLM.
from tavily import TavilyClient
client = TavilyClient(apikey="tvly-YOURAPIKEY")
context = client.getsearchcontext(
query="Bagaimana cara fine-tuning LLM dengan LoRA?",
searchdepth="advanced",
maxtokens=4000
)
print(type(context)) #
print(len(context)) # Panjang konteks yang sudah dioptimalkan
print(context[:500]) # Preview konteks
Menggunakan Context dengan OpenAI
from tavily import TavilyClient
from openai import OpenAI
tavilyclient = TavilyClient(apikey="tvly-YOURAPIKEY")
openaiclient = OpenAI(apikey="sk-YOURAPIKEY")
userquestion = "Apa best practices untuk deploy ML model ke production di 2026?"
context = tavilyclient.getsearchcontext(
query=userquestion,
searchdepth="advanced",
maxtokens=4000
)
response = openaiclient.chat.completions.create(
model="gpt-4o",
messages=[
{
"role": "system",
"content": f"""Kamu adalah AI assistant yang menjawab berdasarkan konteks terkini.
Gunakan konteks berikut untuk menjawab pertanyaan user:
{context}
Jika informasi tidak ada dalam konteks, katakan bahwa kamu tidak memiliki informasi tersebut."""
},
{
"role": "user",
"content": userquestion
}
]
)
print(response.choices[0].message.content)
Q&A Search
Method qnasearch memberikan jawaban langsung dalam format string, cocok untuk chatbot atau quick-answer systems.
answer = client.qnasearch(
query="Siapa CEO Anthropic dan kapan perusahaan didirikan?",
searchdepth="advanced"
)
print(answer)
Output: "Dario Amodei adalah CEO Anthropic. Perusahaan ini didirikan pada tahun 2021..."
Integrasi dengan LangChain
Tavily memiliki integrasi resmi dengan LangChain, menjadikannya tool yang sangat powerful untuk membangun AI agents.
Instalasi
pip install langchain-community tavily-python langchain-openai
Tavily sebagai LangChain Tool
import os
from langchaincommunity.tools.tavilysearch import TavilySearchResults
from langchainopenai import ChatOpenAI
from langchain.agents import AgentExecutor, createtoolcallingagent
from langchaincore.prompts import ChatPromptTemplate
os.environ["TAVILYAPIKEY"] = "tvly-YOURAPIKEY"
os.environ["OPENAIAPIKEY"] = "sk-YOURAPIKEY"
searchtool = TavilySearchResults(
maxresults=5,
searchdepth="advanced",
includeanswer=True,
includerawcontent=False
)
tools = [searchtool]
prompt = ChatPromptTemplate.frommessages([
("system", "Kamu adalah research assistant yang membantu mencari informasi terkini dari internet. Selalu berikan sumber URL untuk setiap informasi."),
("human", "{input}"),
("placeholder", "{agentscratchpad}")
])
llm = ChatOpenAI(model="gpt-4o", temperature=0)
agent = createtoolcallingagent(llm, tools, prompt)
agentexecutor = AgentExecutor(agent=agent, tools=tools, verbose=True)
result = agentexecutor.invoke({
"input": "Apa perkembangan terbaru dalam open-source LLM?"
})
print(result["output"])
Tavily sebagai LangChain Retriever
from langchaincommunity.retrievers import TavilySearchAPIRetriever
retriever = TavilySearchAPIRetriever(
k=5,
search
depth="advanced",
includegeneratedanswer=True
)
docs = retriever.invoke("Cara menggunakan vector database untuk RAG")
for doc in docs:
print(f"Source: {doc.metadata['source']}")
print(f"Content: {doc.pagecontent[:200]}...")
print("---")
RAG Chain dengan LangChain + Tavily
from langchaincommunity.retrievers import TavilySearchAPIRetriever
from langchainopenai import ChatOpenAI
from langchaincore.prompts import ChatPromptTemplate
from langchaincore.outputparsers import StrOutputParser
from langchaincore.runnables import RunnablePassthrough
retriever = TavilySearchAPIRetriever(k=5, searchdepth="advanced")
llm = ChatOpenAI(model="gpt-4o", temperature=0)
template = """Jawab pertanyaan berikut berdasarkan konteks yang diberikan.
Sertakan sumber URL jika memungkinkan.
Konteks:
{context}
Pertanyaan: {question}
Jawaban:"""
prompt = ChatPromptTemplate.fromtemplate(template)
def formatdocs(docs):
return "\n\n".join([
f"Source: {doc.metadata.get('source', 'N/A')}\n{doc.pagecontent}"
for doc in docs
])
chain = (
{"context": retriever | formatdocs, "question": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
)
answer = chain.invoke("Apa itu mixture of experts dalam LLM?")
print(answer)
Integrasi dengan LlamaIndex
pip install llama-index llama-index-tools-tavily-research
from llamaindex.tools.tavilyresearch import TavilyToolSpec
from llamaindex.core.agent import ReActAgent
from llamaindex.llms.openai import OpenAI
tavilytool = TavilyToolSpec(apikey="tvly-YOURAPIKEY")
tools = tavilytool.totoollist()
llm = OpenAI(model="gpt-4o", temperature=0)
agent = ReActAgent.fromtools(tools, llm=llm, verbose=True)
response = agent.chat("Cari informasi terbaru tentang framework AI agents di 2026")
print(response)
Membangun Research Agent dengan Tavily
Berikut contoh lengkap membangun research agent yang dapat melakukan multi-step research:
from tavily import TavilyClient
from openai import OpenAI
import json
class ResearchAgent:
def init(self, tavilyapikey, openaiapikey):
self.tavily = TavilyClient(apikey=tavilyapikey)
self.openai = OpenAI(apikey=openaiapikey)
self.researchdata = []
def generatesearchqueries(self, topic):
"""Generate multiple search queries untuk research yang lebih mendalam."""
response = self.openai.chat.completions.create(
model="gpt-4o",
messages=[
{
"role": "system",
"content": "Generate 3 search queries berbeda untuk research topic berikut. Return sebagai JSON array of strings."
},
{
"role": "user",
"content": f"Topic: {topic}"
}
],
responseformat={"type": "jsonobject"}
)
result = json.loads(response.choices[0].message.content)
return result.get("queries", [topic])
def searchandcollect(self, queries):
"""Jalankan multiple searches dan kumpulkan hasilnya."""
allresults = []
seenurls = set()
for query in queries:
print(f"Searching: {query}")
response = self.tavily.search(
query=query,
searchdepth="advanced",
maxresults=5,
includeanswer=True
)
for result in response["results"]:
if result["url"] not in seenurls:
seenurls.add(result["url"])
allresults.append({
"query": query,
"title": result["title"],
"url": result["url"],
"content": result["content"],
"score": result["score"]
})
if response.get("answer"):
allresults.append({
"query": query,
"title": "AI-Generated Summary",
"url": "tavily-answer",
"content": response["answer"],
"score": 1.0
})
self.researchdata = sorted(allresults, key=lambda x: x["score"], reverse=True)
return self.researchdata
def synthesizereport(self, topic):
"""Synthesize semua data research menjadi laporan terstruktur."""
context = "\n\n".join([
f"Source: {r['title']} ({r['url']})\n{r['content']}"
for r in self.researchdata[:10]
])
response = self.openai.chat.completions.create(
model="gpt-4o",
messages=[
{
"role": "system",
"content": """Kamu adalah research analyst. Buat laporan research yang komprehensif
berdasarkan data yang dikumpulkan. Laporan harus terstruktur dengan:
Executive Summary
Key Findings (dengan bullet points)
Analysis
Kesimpulan dan Rekomendasi
Sertakan referensi URL untuk setiap klaim."""
},
{
"role": "user",
"content": f"Topic: {topic}\n\nResearch Data:\n{context}"
}
]
)
return response.choices[0].message.content
def research(self, topic):
"""Jalankan full research pipeline."""
print(f"Starting research on: {topic}\n")
print("Step 1: Generating search queries...")
queries = self.generatesearchqueries(topic)
print(f"Generated {len(queries)} queries\n")
print("Step 2: Searching and collecting data...")
results = self.searchandcollect(queries)
print(f"Collected {len(results)} unique results\n")
print("Step 3: Synthesizing report...")
report = self.synthesizereport(topic)
return {
"topic": topic,
"queriesused": queries,
"sourcescount": len(results),
"report": report,
"sources": [{"title": r["title"], "url": r["url"]} for r in results]
}
agent = ResearchAgent(
tavilyapikey="tvly-YOURAPIKEY",
openaiapikey="sk-YOURAPIKEY"
)
result = agent.research("State of AI Agents in 2026")
print(result["report"])
Extract API
Tavily juga menyediakan Extract API untuk mengekstrak konten dari URL tertentu:
from tavily import TavilyClient
client = TavilyClient(apikey="tvly-YOURAPIKEY")
response = client.extract(
urls=[
"https://arxiv.org/abs/2005.11401",
"https://huggingface.co/blog/rag-evaluation"
]
)
for result in response["results"]:
print(f"URL: {result['url']}")
print(f"Content length: {len(result['rawcontent'])} chars")
print(f"Content preview: {result['rawcontent'][:300]}...")
print("---")
Ini berguna ketika Anda sudah tahu URL mana yang ingin diekstrak kontennya, misalnya dari hasil pencarian sebelumnya atau dari referensi dalam dokumen.
Best Practices
1. Optimasi Query
# Kurang optimal - terlalu umum
result = client.search("AI")
Lebih optimal - spesifik dan kontekstual
result = client.search(
"practical applications of AI agents in enterprise software development 2026",
searchdepth="advanced"
)
2. Gunakan Domain Filtering
# Untuk research akademis
result = client.search(
"transformer attention mechanism improvements",
includedomains=["arxiv.org", "paperswithcode.com", "scholar.google.com"]
)
Untuk tutorial teknis
result = client.search(
"deploy FastAPI with Docker",
includedomains=["docs.docker.com", "fastapi.tiangolo.com", "realpython.com"]
)
3. Caching untuk Mengurangi API Calls
import hashlib
import json
from pathlib import Path
class CachedTavilyClient:
def init(self, apikey, cachedir="./tavilycache"):
self.client = TavilyClient(apikey=apikey)
self.cachedir = Path(cachedir)
self.cachedir.mkdir(existok=True)
def cachekey(self, query, kwargs):
keydata = json.dumps({"query": query, kwargs}, sortkeys=True)
return hashlib.md5(keydata.encode()).hexdigest()
def search(self, query, cachettl=3600, kwargs):
cachekey = self.cachekey(query, kwargs)
cachefile = self.cachedir / f"{cachekey}.json"
if cachefile.exists():
import time
cachedata = json.loads(cachefile.readtext())
if time.time() - cachedata["timestamp"] < cachettl:
return cachedata["response"]
response = self.client.search(query, kwargs)
import time
cachedata = {"timestamp": time.time(), "response": response}
cachefile.writetext(json.dumps(cachedata))
return response
4. Error Handling yang Tepat
from tavily import TavilyClient
import time
def robustsearch(client, query, maxretries=3, kwargs):
for attempt in range(maxretries):
try:
return client.search(query, kwargs)
except Exception as e:
if "rate limit" in str(e).lower():
waittime = 2 attempt
print(f"Rate limited. Waiting {waittime}s...")
time.sleep(waittime)
elif attempt == maxretries - 1:
raise
else:
print(f"Error: {e}. Retrying...")
time.sleep(1)
5. Batching untuk Multiple Queries
import asyncio
from tavily import AsyncTavilyClient
async def batchsearch(queries, apikey):
client = AsyncTavilyClient(apikey=apikey)
tasks = [
client.search(query, searchdepth="basic")
for query in queries
]
results = await asyncio.gather(*tasks, returnexceptions=True)
successful = []
for query, result in zip(queries, results):
if isinstance(result, Exception):
print(f"Failed: {query} - {result}")
else:
successful.append({"query": query, "results": result})
return successful
queries = [
"Python async programming best practices",
"FastAPI vs Django REST framework comparison",
"Docker multi-stage build optimization"
]
results = asyncio.run(batchsearch(queries, "tvly-YOURAPIKEY"))
Tavily dengan CrewAI
Tavily sangat cocok digunakan dengan framework multi-agent seperti CrewAI:
from crewai import Agent, Task, Crew
from crewaitools import TavilySearchTool
searchtool = TavilySearchTool(apikey="tvly-YOURAPIKEY")
researcher = Agent(
role="Senior Research Analyst",
goal="Menemukan informasi terkini dan akurat tentang topik yang diberikan",
backstory="Kamu adalah research analyst berpengalaman yang selalu mencari data dari sumber terpercaya.",
tools=[searchtool],
verbose=True
)
writer = Agent(
role="Technical Writer",
goal="Menulis artikel teknis berdasarkan hasil research",
backstory="Kamu adalah technical writer yang bisa mengubah data research menjadi artikel yang mudah dipahami.",
verbose=True
)
researchtask = Task(
description="Research tentang: {topic}. Kumpulkan minimal 5 sumber berbeda.",
expectedoutput="Laporan research dengan sumber URL",
agent=researcher
)
writingtask = Task(
description="Tulis artikel berdasarkan hasil research. Include code examples jika relevan.",
expectedoutput="Artikel lengkap dalam markdown",
agent=writer
)
crew = Crew(
agents=[researcher, writer],
tasks=[researchtask, writingtask],
verbose=True
)
result = crew.kickoff(inputs={"topic": "AI Agent Frameworks Comparison 2026"})
print(result)
Perbandingan dengan Alternatif Lain
| Fitur | Tavily | SerpAPI | Google Custom Search | Bing Search API |
|-------|--------|---------|---------------------|-----------------|
| Optimized for AI | Ya | Tidak | Tidak | Tidak |
| Content Extraction | Built-in | Tidak | Tidak | Tidak |
| AI Answer | Ya | Tidak | Tidak | Tidak |
| LangChain Integration | Native | Community | Community | Community |
| Free Tier | 1000/bulan | 100/bulan | 100/hari | 1000/bulan |
| Search Depth | Basic + Advanced | Single | Single | Single |
| Domain Filtering | Ya | Ya | Ya | Ya |
Kesimpulan
Tavily adalah pilihan yang sangat baik untuk developer yang membangun aplikasi AI yang membutuhkan akses ke informasi real-time dari internet. Keunggulan utamanya adalah:
Dengan memanfaatkan Tavily dalam pipeline RAG Anda, Anda dapat membangun aplikasi AI yang selalu memiliki akses ke informasi terkini tanpa harus mengelola infrastruktur web scraping yang kompleks. Kombinasikan dengan framework seperti LangChain atau CrewAI untuk membangun AI agents yang benar-benar powerful dan well-informed.