Tutorial Lengkap Tavily: AI Search API untuk RAG dan AI Agents

# 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...

By Ruby Abdullah · · tutorial
TavilyRAGAI SearchLangChainAI Agents

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:

  • Search API tradisional hanya mengembalikan URL dan snippet pendek, sehingga perlu scraping tambahan
  • Web scraping membutuhkan maintenance yang tinggi karena struktur website sering berubah
  • Konteks yang tidak relevan — hasil pencarian umum seringkali mengandung iklan, navigasi, dan konten yang tidak relevan
  • Token waste — mengirim terlalu banyak konten yang tidak relevan ke LLM membuang token dan meningkatkan biaya
  • 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

  • Kunjungi tavily.com dan buat akun
  • Di dashboard, copy API key Anda
  • Set sebagai environment variable:
  • 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

    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

    }

    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:

    • Lebih cepat (rata-rata 1-2 detik)
    • Cocok untuk pertanyaan umum dan fakta sederhana
    • Biaya lebih rendah per query
    • Menggunakan 1 API credit

    • 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)

    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,

    searchdepth="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:

  • Didesain untuk AI — output sudah dioptimalkan untuk konsumsi LLM, mengurangi token waste
  • Integrasi yang mudah — native support untuk LangChain, LlamaIndex, dan CrewAI
  • Fitur lengkap — search, extract, context, dan Q&A dalam satu API
  • Developer-friendly — SDK untuk Python dan Node.js, dokumentasi yang baik
  • Cost-effective — free tier generous, pricing yang kompetitif
  • 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.

    Artikel Terkait

    Tutorial LangChain: Framework Paling Populer untuk Membangun Aplikasi LLM

    Tutorial LangChain: Framework Paling Populer untuk Membangun Aplikasi LLM LangChain adalah framework open-source yang di...

    Tutorial Lengkap Griptape: Framework Python untuk Membangun AI Agent dan Pipeline

    Tutorial Lengkap Griptape: Framework Python untuk Membangun AI Agent dan Pipeline Griptape adalah framework open-source ...

    Tutorial Mastra: Framework TypeScript untuk Membangun AI Agent dan Workflow

    Tutorial Mastra: Framework TypeScript untuk Membangun AI Agent dan Workflow Mastra adalah framework open-source berbasis...

    Tutorial Lengkap Dify: Platform Open-Source untuk Membangun Aplikasi AI

    Tutorial Lengkap Dify: Platform Open-Source untuk Membangun Aplikasi AI Dify adalah platform open-source yang memungkink...