Using Tavily Search Tool

Tavily Search API connects large language models (LLMs) to the web, enabling fast, persistent web search results you can inject as context for retrieval-augmented generation (RAG) workflows. This guide shows how to fetch results from Tavily and use them with an LLM (for example, via LangChain) to create search-augmented prompts or document stores.

The image is a webpage for Tavily AI, promoting a search API that connects large language models to the web for efficient, quick, and persistent search results. It features buttons to open GitHub and join the community.

Overview

Use Tavily to perform web searches and collect the returned page snippets and URLs.
Store your Tavily API key securely (environment variable recommended) and never commit secrets to source control.
Aggregate, chunk, or index the returned content to provide up-to-date, cited context to your LLM.

Getting your API key

Sign up for Tavily and visit your dashboard.
Copy the API key and set it as an environment variable on your machine or deployment environment (example below).

The image shows a web page interface for "Tavily AI" with an "Overview" section displaying a "Researcher" plan, API usage details, and an API key authentication area. There are menu options on the left and a contact button at the bottom.

Tavily often provides a free developer tier (for example, 1,000 calls/month at the time of writing). Store your API key in an environment variable such as TAVILY_API_KEY and avoid hard-coding secrets in source files.

Quick example using the LangChain community tool wrapper

The LangChain community package provides a TavilySearchResults wrapper to simplify queries and return structured results.
The wrapper typically reads the TAVILY_API_KEY environment variable when initialized.

Setup and usage

Export your API key locally:

export TAVILY_API_KEY="your_api_key_here"

Minimal Python usage:

# example_tavily_search.py
from langchain_community.tools.tavily_search import TavilySearchResults
import os

# Optionally read the env var in code (not required if the wrapper reads it internally)
TAVILY_API_KEY = os.getenv("TAVILY_API_KEY")

# Initialize the tool (wrapper may read TAVILY_API_KEY automatically)
tool = TavilySearchResults()

# Perform a search
response = tool.invoke({"query": "When is ICC Men's T20 World Cup 2024 starting?"})

# Inspect the response
print(type(response))         # typically a list
print(len(response))          # default number of results (usually 5)
print(response[0]['url'])     # first result URL
print(response[0]['content']) # first result content snippet

Example of the returned structure

The invoke method returns a list of dictionaries. Each dictionary typically includes url and content keys (snippet of the page).
Example (trimmed):

[
  {
    "url": "https://www.espncricinfo.com/series/icc-men-s-t20-world-cup-2024-1411166/match-schedule-fixtures-and-results",
    "content": "Get 2024 T20 World Cup schedule, fixtures, scorecard updates, and results on ESPNcricinfo. Track latest match scores, schedule, and results of ICC Men's T20 World Cup 2024."
  },
  {
    "url": "https://www.skysports.com/cricket/news/12123/13042693/icc-mens-t20-cricket-world-cup-2024-fixtures-schedule-and-start-times-with-all-matches-live-on-sky-sports",
    "content": "Group D - Sri Lanka vs Bangladesh (Dallas)\nSaturday June 8\nGroup A - Netherlands vs South Africa (New York)\nGroup B - Australia vs England (Barbados)\nSunday June 9\nGroup A - India vs Pakistan (New York)"
  }
]

Result fields summary

Field	Description	Example
`url`	Source page URL for the search result	`https://example.com/article`
`content`	Text snippet or extract from the page (use for context)	`"Match schedule and results for ICC Men's T20 World Cup 2024..."`

Combining and chunking results for RAG

The default response often returns five results. Aggregate and chunk content fields, then include the most relevant chunks (with URLs) as context in your LLM prompt.
Example: join all content into one string before chunking or indexing.

all_text = "\n\n".join(r["content"] for r in response)
sources = [r["url"] for r in response]

print("Combined text length:", len(all_text))
print("Sources:", sources)

Best practices and tips

Prioritize relevance: sort or filter results by relevance before concatenating content.
Chunking: split large combined text into smaller chunks that respect your LLM context window.
Citation: always include source URLs in your final output so results are verifiable.
Rate limits: respect Tavily’s API rate limits; implement retries and backoff where appropriate.
Security: keep API keys in secrets management (environment variables, secret managers, or vaults).

Never commit your TAVILY_API_KEY (or any secret) to version control. Use environment variables or a secrets manager in production to avoid accidental exposure.

Integrations and next steps

Use Tavily results directly in prompts for short answers (with citations).
For larger systems, index the returned snippets into a vector store and perform semantic retrieval before calling your LLM.
Integrate the tool into a LangChain toolset or agent to automate search-and-answer workflows.

Introduction

Overview of LangChain

Key Components of LangChain

Interacting with LLMs

Tips, Tricks, and Resources

Introduction to LCEL

Adding Memory to LLM Apps

Performing Retrieval

Implementing Chains

Using Tools

Building Agents

Conclusion

Building Blocks of LLM Apps

Using Tavily Search Tool

Watch Video