1# Framework Integrations
2 
3## Table of Contents
4 
5- [LangChain](#langchain)
6- [Pydantic AI](#pydantic-ai)
7- [LlamaIndex](#llamaindex)
8- [Agno](#agno)
9- [OpenAI Function Calling](#openai-function-calling)
10- [Anthropic Tool Calling](#anthropic-tool-calling)
11- [Google ADK](#google-adk)
12- [Vercel AI SDK](#vercel-ai-sdk)
13- [CrewAI](#crewai)
14- [No-Code Platforms](#no-code-platforms)
15 
16---
17 
18## LangChain
19 
20We recommend the official `langchain-tavily` package for LangChain integrations.
21 
22> Warning: `langchain_community.tools.tavily_search.tool` is deprecated. Migrate to `langchain-tavily` for actively maintained Search, Extract, Map, Crawl, and Research tools.
23 
24### Installation
25 
26```bash
27pip install -U langchain-tavily
28```
29 
30### Credentials
31 
32```python
33import getpass
34import os
35 
36if not os.environ.get("TAVILY_API_KEY"):
37    os.environ["TAVILY_API_KEY"] = getpass.getpass("Tavily API key:\n")
38```
39 
40### Tavily Search
41 
42**Available parameters**
43- `max_results` (default: `5`)
44- `topic` (`"general"`, `"news"`, `"finance"`)
45- `include_answer`
46- `include_raw_content`
47- `include_images`
48- `include_image_descriptions`
49- `search_depth` (`"basic"` or `"advanced"`)
50- `time_range` (`"day"`, `"week"`, `"month"`, `"year"`)
51- `start_date` (`YYYY-MM-DD`)
52- `end_date` (`YYYY-MM-DD`)
53- `include_domains`
54- `exclude_domains`
55- `include_usage`
56 
57**Instantiation**
58 
59```python
60from langchain_tavily import TavilySearch
61 
62tavily_search = TavilySearch(
63    max_results=5,
64    topic="general"
65)
66```
67 
68**Invoke directly with args**
69- Required: `query`
70- Can also be overridden at invocation: `include_images`, `search_depth`, `time_range`, `include_domains`, `exclude_domains`, `start_date`, `end_date`
71- `include_answer` and `include_raw_content` should be set at instantiation time for predictable response sizes
72 
73```python
74result = tavily_search.invoke({"query": "What happened at the last Wimbledon?"})
75```
76 
77**Use with agent**
78 
79```python
80from langchain.agents import create_agent
81from langchain_openai import ChatOpenAI
82 
83agent = create_agent(
84    model=ChatOpenAI(model="gpt-5"),
85    tools=[tavily_search],
86    system_prompt="You are a helpful research assistant. Use web search to find accurate, up-to-date information.",
87)
88response = agent.invoke({
89    "messages": [{
90        "role": "user",
91        "content": "What is the most popular sport in the world? Include only Wikipedia sources.",
92    }]
93})
94```
95 
96Tip: include today's date in the system prompt for time-aware queries.
97 
98### Tavily Extract
99 
100**Available parameters**
101- `extract_depth` (`"basic"` or `"advanced"`)
102- `include_images`
103 
104```python
105from langchain_tavily import TavilyExtract
106 
107tavily_extract = TavilyExtract(
108    extract_depth="basic",  # or "advanced"
109    # include_images=False,
110)
111 
112result = tavily_extract.invoke({
113    "urls": ["https://en.wikipedia.org/wiki/Lionel_Messi"]
114})
115```
116 
117### Tavily Map/Crawl
118 
119```python
120from langchain_tavily import TavilyMap
121 
122tavily_map = TavilyMap()
123 
124result = tavily_map.invoke({
125    "url": "https://docs.example.com",
126    "instructions": "Find all documentation and tutorial pages"
127})
128# Returns: {"base_url": ..., "results": [urls...], "response_time": ...}
129```
130 
131```python
132from langchain_tavily import TavilyCrawl
133 
134tavily_crawl = TavilyCrawl()
135 
136result = tavily_crawl.invoke({
137    "url": "https://docs.example.com",
138    "instructions": "Extract API documentation and code examples"
139})
140# Returns: {"base_url": ..., "results": [{url, raw_content}...], "response_time": ...}
141```
142 
143### Tavily Research
144 
145**Available parameters**
146- `input` (required)
147- `model` (`"mini"`, `"pro"`, `"auto"`)
148- `output_schema`
149- `stream`
150- `citation_format` (`"numbered"`, `"mla"`, `"apa"`, `"chicago"`)
151 
152```python
153from langchain_tavily import TavilyResearch
154 
155tavily_research = TavilyResearch()
156 
157result = tavily_research.invoke({
158    "input": "Research the latest developments in AI and summarize key trends.",
159    "model": "mini",
160    "citation_format": "apa"
161})
162```
163 
164### Tavily Get Research
165 
166```python
167from langchain_tavily import TavilyGetResearch
168 
169tavily_get_research = TavilyGetResearch()
170final = tavily_get_research.invoke({"request_id": result["request_id"]})
171```
172 
173---
174 
175## Pydantic AI
176 
177Tavily is available for integration through Pydantic AI.
178 
179### Introduction
180 
181Integrate Tavily with Pydantic AI to enhance your AI agents with powerful web search capabilities. Pydantic AI provides a framework for building AI agents with tools, making it easy to incorporate real-time web search and data extraction into your applications.
182 
183### Step-by-Step Integration Guide
184 
185#### Step 1: Install Required Packages
186 
187Install the necessary Python packages:
188 
189```bash
190pip install "pydantic-ai-slim[tavily]"
191```
192 
193#### Step 2: Set Up API Keys
194 
195- Tavily API Key: [Get your Tavily API key](https://app.tavily.com/home)
196 
197Set this as an environment variable:
198 
199```bash
200export TAVILY_API_KEY=your_tavily_api_key
201```
202 
203#### Step 3: Initialize Pydantic AI Agent with Tavily Tools
204 
205```python
206import os
207from pydantic_ai.agent import Agent
208from pydantic_ai.common_tools.tavily import tavily_search_tool
209 
210# Get API key from environment
211api_key = os.getenv("TAVILY_API_KEY")
212assert api_key is not None
213 
214# Initialize the agent with Tavily tools
215agent = Agent(
216    "openai:o3-mini",
217    tools=[tavily_search_tool(api_key)],
218    system_prompt="Search Tavily for the given query and return the results.",
219)
220```
221 
222#### Step 4: Example Use Cases
223 
224```python
225# Example 1: Basic search for news
226result = agent.run_sync("Tell me the top news in the GenAI world, give me links.")
227print(result.output)
228```
229 
230---
231 
232## LlamaIndex
233 
234```python
235from llama_index.tools.tavily_research import TavilyToolSpec
236 
237# Initialize tools
238tavily_tool = TavilyToolSpec(api_key="tvly-YOUR_API_KEY")
239tools = tavily_tool.to_tool_list()
240 
241# Use with agent
242from llama_index.agent.openai import OpenAIAgent
243 
244agent = OpenAIAgent.from_tools(tools)
245response = agent.chat("What are the latest AI developments?")
246```
247 
248---
249 
250## Agno
251 
252Tavily is available for integration through Agno, a lightweight framework for building agents with tools, memory, and reasoning.
253 
254### Introduction
255 
256Integrate Tavily with Agno to enhance your AI agents with powerful web search capabilities. Agno makes it easy to incorporate real-time web search and data extraction into your AI applications.
257 
258### Step-by-Step Integration Guide
259 
260#### Step 1: Install Required Packages
261 
262```bash
263pip install agno tavily-python
264```
265 
266#### Step 2: Set Up API Keys
267 
268- Tavily API Key: [Get your Tavily API key](https://app.tavily.com/home)
269- OpenAI API Key: [Get your OpenAI API key](https://platform.openai.com/api-keys)
270 
271Set these as environment variables:
272 
273```bash
274export TAVILY_API_KEY=your_tavily_api_key
275export OPENAI_API_KEY=your_openai_api_key
276```
277 
278#### Step 3: Initialize Agno Agent with Tavily Tools
279 
280```python
281from agno.agent import Agent
282from agno.tools.tavily import TavilyTools
283 
284# Initialize the agent with Tavily tools
285agent = Agent(
286    tools=[
287        TavilyTools(
288            search=True,             # Enable search functionality
289            max_tokens=8000,         # Increase max tokens for detailed results
290            search_depth="advanced", # Use advanced search for comprehensive results
291            format="markdown",       # Format results as markdown
292        )
293    ],
294    show_tool_calls=True,
295)
296```
297 
298#### Step 4: Example Use Cases
299 
300```python
301# Example 1: Basic search with default parameters
302agent.print_response("Latest developments in quantum computing", markdown=True)
303 
304# Example 2: Market research with multiple parameters
305agent.print_response(
306    "Analyze the competitive landscape of AI-powered customer service solutions in 2026, "
307    "focusing on market leaders and emerging trends",
308    markdown=True,
309)
310 
311# Example 3: Technical documentation search
312agent.print_response(
313    "Find the latest documentation and tutorials about Python async programming, "
314    "focusing on asyncio and FastAPI",
315    markdown=True,
316)
317 
318# Example 4: News aggregation
319agent.print_response(
320    "Gather the latest news about artificial intelligence from tech news websites "
321    "published in the last week",
322    markdown=True,
323)
324```
325 
326### Additional Use Cases
327 
328- Content curation: Gather and organize information from multiple sources
329- Real-time data integration: Keep your AI agents up to date with the latest information
330- Technical documentation: Search and analyze technical documentation
331- Market analysis: Conduct comprehensive market research and analysis
332 
333---
334 
335## OpenAI Function Calling
336 
337Define Tavily as an OpenAI function:
338 
339```python
340from openai import OpenAI
341from tavily import TavilyClient
342import json
343 
344openai_client = OpenAI()
345tavily_client = TavilyClient()
346 
347tools = [{
348    "type": "function",
349    "function": {
350        "name": "web_search",
351        "description": "Search the web for current information",
352        "parameters": {
353            "type": "object",
354            "properties": {
355                "query": {
356                    "type": "string",
357                    "description": "The search query"
358                }
359            },
360            "required": ["query"]
361        }
362    }
363}]
364 
365def handle_tool_call(tool_call):
366    if tool_call.function.name == "web_search":
367        args = json.loads(tool_call.function.arguments)
368        return tavily_client.search(args["query"])
369 
370# Chat completion with tools
371response = openai_client.chat.completions.create(
372    model="gpt-4",
373    messages=[{"role": "user", "content": "What are the latest AI trends?"}],
374    tools=tools
375)
376 
377if response.choices[0].message.tool_calls:
378    tool_call = response.choices[0].message.tool_calls[0]
379    search_results = handle_tool_call(tool_call)
380 
381    # Continue conversation with results
382    messages = [
383        {"role": "user", "content": "What are the latest AI trends?"},
384        response.choices[0].message,
385        {"role": "tool", "tool_call_id": tool_call.id, "content": json.dumps(search_results)}
386    ]
387    final = openai_client.chat.completions.create(
388        model="gpt-4",
389        messages=messages
390    )
391```
392 
393---
394 
395## Anthropic Tool Calling
396 
397Integrate Tavily with Anthropic Claude to add real-time web search in tool-calling workflows.
398 
399### Installation
400 
401```bash
402pip install anthropic tavily-python
403```
404 
405### Setup
406 
407```bash
408export ANTHROPIC_API_KEY="your-anthropic-api-key"
409export TAVILY_API_KEY="your-tavily-api-key"
410```
411 
412### Using Tavily With Anthropic Tool Calling
413 
414```python
415import json
416import os
417from anthropic import Anthropic
418from tavily import TavilyClient
419 
420client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
421tavily_client = TavilyClient(api_key=os.environ["TAVILY_API_KEY"])
422MODEL_NAME = "claude-sonnet"
423```
424 
425### Implementation
426 
427#### System prompt
428 
429```python
430SYSTEM_PROMPT = (
431    "You are a research assistant. Use the tavily_search tool when needed. "
432    "After tools run and tool results are provided back to you, produce a concise, "
433    "well-structured summary with key bullets and a Sources section listing URLs."
434)
435```
436 
437#### Tool schema
438 
439```python
440tools = [
441    {
442        "name": "tavily_search",
443        "description": "Search the web using Tavily and return relevant links and summaries.",
444        "input_schema": {
445            "type": "object",
446            "properties": {
447                "query": {"type": "string", "description": "Search query string."},
448                "max_results": {"type": "integer", "default": 5},
449                "search_depth": {
450                    "type": "string",
451                    "enum": ["basic", "advanced"],
452                    "default": "basic",
453                },
454            },
455            "required": ["query"],
456        },
457    }
458]
459```
460 
461#### Tool execution
462 
463```python
464def tavily_search(**kwargs):
465    return tavily_client.search(**kwargs)
466 
467def process_tool_call(name, args):
468    if name == "tavily_search":
469        return tavily_search(**args)
470    raise ValueError(f"Unknown tool: {name}")
471```
472 
473#### Main chat function
474 
475```python
476def chat_with_claude(user_message: str):
477    # Call 1: allow tool use
478    initial_response = client.messages.create(
479        model=MODEL_NAME,
480        max_tokens=4096,
481        system=SYSTEM_PROMPT,
482        messages=[{"role": "user", "content": [{"type": "text", "text": user_message}]}],
483        tools=tools,
484    )
485 
486    # If Claude answers without tools, return text directly
487    if initial_response.stop_reason != "tool_use":
488        return "".join(
489            block.text for block in initial_response.content
490            if getattr(block, "type", None) == "text"
491        )
492 
493    # Execute all requested tools
494    tool_result_blocks = []
495    for block in initial_response.content:
496        if getattr(block, "type", None) == "tool_use":
497            result = process_tool_call(block.name, block.input)
498            tool_result_blocks.append(
499                {
500                    "type": "tool_result",
501                    "tool_use_id": block.id,
502                    "content": json.dumps(result),
503                }
504            )
505 
506    # Call 2: send tool results and ask Claude for final synthesis
507    final_response = client.messages.create(
508        model=MODEL_NAME,
509        max_tokens=4096,
510        system=SYSTEM_PROMPT,
511        messages=[
512            {"role": "user", "content": [{"type": "text", "text": user_message}]},
513            {"role": "assistant", "content": initial_response.content},
514            {"role": "user", "content": tool_result_blocks},
515            {
516                "role": "user",
517                "content": [{
518                    "type": "text",
519                    "text": "Please synthesize the final answer now based on the tool results above. Include 3-7 bullets and a Sources section with URLs.",
520                }],
521            },
522        ],
523    )
524 
525    return "".join(
526        block.text for block in final_response.content
527        if getattr(block, "type", None) == "text"
528    )
529```
530 
531### Usage example
532 
533```python
534chat_with_claude("What is trending now in the agents space in 2026?")
535```
536 
537Reference: https://docs.tavily.com/documentation/integrations/anthropic
538 
539---
540 
541## Google ADK
542 
543Google ADK can connect to Tavily through Tavily's remote MCP server, giving your Gemini-based agent live search, extraction, and site exploration capabilities.
544 
545### Prerequisites
546 
547- Python 3.9+
548- Tavily API key: https://app.tavily.com/home
549- Gemini API key: https://aistudio.google.com/app/apikey
550 
551### Installation
552 
553```bash
554pip install google-adk mcp
555```
556 
557### Agent Setup
558 
559```python
560import os
561from google.adk.agents import Agent
562from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPServerParams
563from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset
564 
565tavily_api_key = os.getenv("TAVILY_API_KEY")
566 
567root_agent = Agent(
568    model="gemini-2.5-pro",
569    name="tavily_agent",
570    instruction=(
571        "You are a helpful assistant that uses Tavily to search the web, "
572        "extract content, and explore websites. Use Tavily tools to provide "
573        "up-to-date information."
574    ),
575    tools=[
576        MCPToolset(
577            connection_params=StreamableHTTPServerParams(
578                url="https://mcp.tavily.com/mcp/",
579                headers={"Authorization": f"Bearer {tavily_api_key}"},
580            )
581        )
582    ],
583)
584```
585 
586### Environment Variables
587 
588```bash
589export GOOGLE_API_KEY="your_gemini_api_key_here"
590export TAVILY_API_KEY="your_tavily_api_key_here"
591```
592 
593### Run
594 
595```bash
596adk create my_agent
597adk run my_agent
598# Optional web UI:
599adk web --port 8000
600```
601 
602### Available Tavily MCP tools
603 
604- `tavily-search`
605- `tavily-extract`
606- `tavily-map`
607- `tavily-crawl`
608 
609Reference: https://docs.tavily.com/documentation/integrations/google-adk
610 
611---
612 
613## Vercel AI SDK
614 
615The `@tavily/ai-sdk` package provides pre-built tools for Vercel AI SDK v5.
616 
617### Installation
618 
619```bash
620npm install ai @ai-sdk/openai @tavily/ai-sdk
621```
622 
623### Usage
624 
625```typescript
626import { tavilySearch, tavilyCrawl } from "@tavily/ai-sdk";
627import { generateText } from "ai";
628import { openai } from "@ai-sdk/openai";
629 
630// Search
631const result = await generateText({
632  model: openai("gpt-4"),
633  prompt: "What are the latest AI developments?",
634  tools: {
635    tavilySearch: tavilySearch({
636      maxResults: 5,
637      searchDepth: "advanced",
638    }),
639  },
640});
641 
642// Crawl
643const crawlResult = await generateText({
644  model: openai("gpt-4"),
645  prompt: "Crawl tavily.com and summarize their features",
646  tools: {
647    tavilyCrawl: tavilyCrawl({
648      maxDepth: 2,
649      limit: 50,
650    }),
651  },
652});
653```
654 
655**Available tools:** `tavilySearch`, `tavilyExtract`, `tavilyCrawl`, `tavilyMap`
656 
657---
658 
659## CrewAI
660 
661CrewAI provides built-in Tavily tools for multi-agent workflows.
662 
663### Installation
664 
665```bash
666pip install 'crewai[tools]'
667```
668 
669### Usage
670 
671```python
672import os
673from crewai import Agent, Task, Crew
674from crewai_tools import TavilySearchTool, TavilyExtractTool
675 
676os.environ["TAVILY_API_KEY"] = "your-api-key"
677 
678# Search tool
679search_tool = TavilySearchTool()
680 
681# Create agent with Tavily
682researcher = Agent(
683    role="Research Analyst",
684    goal="Find and analyze information on given topics",
685    tools=[search_tool],
686    backstory="Expert at finding relevant information online"
687)
688 
689task = Task(
690    description="Research the latest developments in quantum computing",
691    expected_output="A comprehensive summary with sources",
692    agent=researcher
693)
694 
695crew = Crew(agents=[researcher], tasks=[task])
696result = crew.kickoff()
697```
698 
699---
700 
701## No-Code Platforms
702 
703Tavily integrates with popular no-code automation platforms:
704 
705| Platform | Features | Best For |
706|----------|----------|----------|
707| **Zapier** | Search, Extract | CRM enrichment, automated research |
708| **Make** | Search, Extract | Complex workflows, multi-step automations |
709| **n8n** | Search, Extract, AI Agent tool | Self-hosted, AI agent workflows |
710| **Dify** | Search, Extract | No-code AI apps, chatflows |
711| **FlowiseAI** | Search | Visual LLM builders, RAG systems |
712| **Langflow** | Search, Extract | Visual agent building |
713 
714---
715 
716## Additional Integrations
717See the [full integrations documentation](https://docs.tavily.com/documentation/integrations) for complete guides.
718