> ## Documentation Index
> Fetch the complete documentation index at: https://praison.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# LangChain Agent

> Learn how to use LangChain tools and utilities with PraisonAI agents.

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents import Agent
from langchain_community.tools import WikipediaQueryRun

agent = Agent(
    name="LangChain Agent",
    instructions="Answer using LangChain community tools.",
    tools=[WikipediaQueryRun()],
)
agent.start("Give a short overview of reinforcement learning from Wikipedia")
```

The user requests external knowledge; the agent queries LangChain tools and returns a summary.

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
graph LR
    U[Input] --> A[Agent]
    A --> T[Tool]
    T --> O[Output]

    classDef agent fill:#8B0000,color:#fff
    classDef tool fill:#189AB4,color:#fff

    class A agent
    class U,O tool
    class T tool
```

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
sequenceDiagram
    participant User
    participant Agent
    participant Feature as LangChain Agent

    User->>Agent: Request
    Agent->>Feature: Process request
    Feature-->>Agent: Result
    Agent-->>User: Response
```

## Quick Start

<Tabs>
  <Tab title="Code">
    <Steps>
      <Step title="Install Package">
        First, install the required packages:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        pip install praisonaiagents langchain-community wikipedia youtube-search
        ```
      </Step>

      <Step title="Set API Key">
        Set your OpenAI API key as an environment variable in your terminal:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        export OPENAI_API_KEY=your_api_key_here
        ```
      </Step>

      <Step title="Create a file">
        Create a new file `app.py` with the basic setup:

        <CodeGroup>
          ```python Single Tool theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
          from praisonaiagents import Agent
          from langchain_community.utilities import WikipediaAPIWrapper

          wiki_agent = Agent(
            instructions="You are a wikipedia research Agent",
            tools=[WikipediaAPIWrapper]
          )

          wiki_agent.start("Research 'Artificial Intelligence' on Wikipedia")
          ```

          ```python Multiple Tools theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
          from praisonaiagents import Agent, AgentTeam
          from langchain_community.utilities import WikipediaAPIWrapper
          from langchain_community.tools import YouTubeSearchTool

          youtube_agent = Agent(
              instructions="Search for information about 'AI advancements' on YouTube",
              tools=[YouTubeSearchTool]
          )

          wiki_agent = Agent(
              instructions="Research 'Artificial Intelligence' on Wikipedia",
              tools=[WikipediaAPIWrapper]
          )

          agents = AgentTeam(agents=[youtube_agent, wiki_agent])
          agents.start()
          ```
        </CodeGroup>
      </Step>

      <Step title="Start Agents">
        Type this in your terminal to run your agents:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        python app.py
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="No Code">
    <Steps>
      <Step title="Install Package">
        (Upcoming Feature)
        Install the PraisonAI package:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        pip install "praisonai"
        ```
      </Step>

      <Step title="Set API Key">
        Set your OpenAI API key as an environment variable in your terminal:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        export OPENAI_API_KEY=your_api_key_here
        ```
      </Step>

      <Step title="Create a file">
        Create a new file `agents.yaml` with the basic setup:

        ```yaml theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        framework: praisonai
        process: sequential
        agents:  # Canonical: use 'agents' instead of 'roles'
          researcher:
            name: SearchAgent
            role: Research Assistant
            goal: Search for information from multiple sources
            instructions:  # Canonical: use 'instructions' instead of 'backstory' I am an AI assistant that can search YouTube and Wikipedia.
            tools:
              - youtube_search
              - wikipedia
            tasks:
              search_task:
                name: search_task
                description: Search for information about 'AI advancements' on both YouTube and Wikipedia
                expected_output: Combined information from YouTube videos and Wikipedia articles
        ```
      </Step>

      <Step title="Start Agents">
        Type this in your terminal to run your agents:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        praisonai agents.yaml
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

<Note>
  **Requirements**

  * Python 3.10 or higher
  * OpenAI API key. Generate OpenAI API key [here](https://platform.openai.com/api-keys)
  * LangChain compatible tools and utilities
</Note>

## Understanding LangChain Integration

<Card title="What is LangChain Integration?" icon="question">
  LangChain integration enables agents to:

  * Use LangChain's extensive tool ecosystem
  * Access various data sources and APIs
  * Leverage pre-built utilities and wrappers
  * Combine multiple tools in a single agent
  * Extend agent capabilities with community tools
</Card>

## Features

<CardGroup cols={2}>
  <Card title="Tool Integration" icon="plug">
    Seamlessly use LangChain tools with PraisonAI agents.
  </Card>

  <Card title="Multiple Sources" icon="database">
    Access various data sources through LangChain utilities.
  </Card>

  <Card title="Community Tools" icon="users">
    Leverage the extensive LangChain community ecosystem.
  </Card>

  <Card title="Custom Tools" icon="wrench">
    Create and integrate custom LangChain tools.
  </Card>
</CardGroup>

## LangChain Tools with Wrappers

<Note>
  * LangChain tools with wrappers can be directly used as Tools without modification.
  * PraisonAI will automatically detect the tool and use it.
  * Some exceptions apply where it doesn't work.
</Note>

### Example Wrapper Usage

```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
pip install langchain-community google-search-results
export SERPAPI_API_KEY=your_api_key_here
export OPENAI_API_KEY=your_api_key_here
```

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents import Agent, AgentTeam
from langchain_community.utilities import SerpAPIWrapper

data_agent = Agent(instructions="Search about AI job trends in 2025", tools=[SerpAPIWrapper])
editor_agent = Agent(instructions="Write a blog article")

agents = AgentTeam(agents=[data_agent, editor_agent])
agents.start()
```

### Example without Wrapper Usage

```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
pip install langchain-community 
export BRAVE_SEARCH_API=your_api_key_here
export OPENAI_API_KEY=your_api_key_here
```

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents import Agent, AgentTeam
from langchain_community.tools import BraveSearch
import os

def search_brave(query: str):
    """Searches using BraveSearch and returns results."""
    api_key = os.environ['BRAVE_SEARCH_API']
    tool = BraveSearch.from_api_key(api_key=api_key, search_kwargs={"count": 3})
    return tool.run(query)

data_agent = Agent(instructions="Search about AI job trends in 2025", tools=[search_brave])
editor_agent = Agent(instructions="Write a blog article")
agents = AgentTeam(agents=[data_agent, editor_agent])
agents.start()
```

## Next Steps

<CardGroup cols={2}>
  <Card title="Memory Integration" icon="brain" href="/docs/concepts/memory">
    Learn how to combine LangChain tools with agent memory
  </Card>

  <Card title="Custom Tools" icon="wrench" href="./tools">
    Create your own custom tools for agents
  </Card>
</CardGroup>

<Note>
  For optimal results, ensure all required dependencies are installed and API keys are properly configured for each tool.
</Note>

## With More Detailed Instructions

<Tabs>
  <Tab title="Code">
    <Steps>
      <Step title="Install Package">
        First, install the required packages:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        pip install praisonaiagents langchain-community wikipedia
        ```
      </Step>

      <Step title="Set API Key">
        Set your OpenAI API key as an environment variable in your terminal:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        export OPENAI_API_KEY=your_api_key_here
        ```
      </Step>

      <Step title="Create a file">
        Create a new file `app.py` with the basic setup:

        <CodeGroup>
          ```python Single Tool theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
          from praisonaiagents import Agent, Task, AgentTeam
          from langchain_community.utilities import WikipediaAPIWrapper

          # Create an agent with Wikipedia tool
          agent = Agent(
              name="WikiAgent",
              role="Research Assistant",
              goal="Search Wikipedia for accurate information",
              backstory="I am an AI assistant specialized in Wikipedia research",
              tools=[WikipediaAPIWrapper],
              reflection=False
          )

          # Create a research task
          task = Task(
              name="wiki_search",
              description="Research 'Artificial Intelligence' on Wikipedia",
              expected_output="Comprehensive information from Wikipedia articles",
              agent=agent
          )

          # Create and start the workflow
          agents = AgentTeam(
              agents=[agent],
              tasks=[task]
          )

          agents.start()
          ```

          ```python Multiple Tools theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
          from praisonaiagents import Agent, Task, AgentTeam
          from langchain_community.tools import YouTubeSearchTool
          from langchain_community.utilities import WikipediaAPIWrapper

          # Create YouTube search agent
          agent = Agent(
              name="SearchAgent",
              role="Research Assistant",
              goal="Search for information from YouTube",
              backstory="I am an AI assistant that can search YouTube for relevant videos.",
              tools=[YouTubeSearchTool],
              reflection=False
          )

          # Create Wikipedia research agent
          agent2 = Agent(
              name="WikiAgent",
              role="Research Assistant",
              goal="Search for information from Wikipedia",
              backstory="I am an AI assistant that can search Wikipedia for accurate information.",
              tools=[WikipediaAPIWrapper],
              reflection=False
          )

          # Create YouTube search task
          task = Task(
              name="search_task",
              description="Search for information about 'AI advancements' on YouTube",
              expected_output="Relevant information from YouTube videos",
              agent=agent
          )

          # Create Wikipedia research task
          task2 = Task(
              name="wiki_task",
              description="Search for information about 'AI advancements' on Wikipedia",
              expected_output="Comprehensive information from Wikipedia articles",
              agent=agent2
          )

          # Create and start the workflow
          agents = AgentTeam(
              agents=[agent, agent2],
              tasks=[task, task2]
          )

          agents.start()
          ```
        </CodeGroup>
      </Step>

      <Step title="Start Agents">
        Type this in your terminal to run your agents:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        python app.py
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="No Code">
    <Steps>
      <Step title="Install Package">
        (Upcoming Feature)
        Install the PraisonAI package:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        pip install "praisonai"
        ```
      </Step>

      <Step title="Set API Key">
        Set your OpenAI API key as an environment variable in your terminal:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        export OPENAI_API_KEY=your_api_key_here
        ```
      </Step>

      <Step title="Create a file">
        Create a new file `agents.yaml` with the basic setup:

        ```yaml theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        framework: praisonai
        process: sequential
        agents:  # Canonical: use 'agents' instead of 'roles'
          researcher:
            name: SearchAgent
            role: Research Assistant
            goal: Search for information from multiple sources
            instructions:  # Canonical: use 'instructions' instead of 'backstory' I am an AI assistant that can search YouTube and Wikipedia.
            tools:
              - youtube_search
              - wikipedia
            tasks:
              search_task:
                name: search_task
                description: Search for information about 'AI advancements' on both YouTube and Wikipedia
                expected_output: Combined information from YouTube videos and Wikipedia articles
        ```
      </Step>

      <Step title="Start Agents">
        Type this in your terminal to run your agents:

        ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
        praisonai agents.yaml
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

## Best Practices

<AccordionGroup>
  <Accordion title="Prefer wrapper utilities over raw tools">
    Pass LangChain `*Wrapper` utilities (e.g. `WikipediaAPIWrapper`, `SerpAPIWrapper`) directly in the `tools=[...]` list. PraisonAI auto-detects callable tools and generates a schema from the signature, so wrappers work without extra glue code. Reach for a plain Python function only when a tool needs API-key setup that a wrapper does not expose.
  </Accordion>

  <Accordion title="Wrap non-standard tools in a function">
    Some LangChain tools require constructor arguments (like an API key) before they can run. Wrap those in a small typed function so the agent gets a clean schema:

    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    from langchain_community.tools import BraveSearch
    import os

    def search_brave(query: str):
        """Search the web with BraveSearch."""
        tool = BraveSearch.from_api_key(api_key=os.environ["BRAVE_SEARCH_API"], search_kwargs={"count": 3})
        return tool.run(query)
    ```
  </Accordion>

  <Accordion title="Write clear docstrings and type hints">
    PraisonAI builds the tool schema from each function's signature and docstring. Add a one-line docstring and annotate every parameter (`query: str`) so the agent knows when and how to call the tool.
  </Accordion>

  <Accordion title="Install only the tools you need">
    LangChain community tools pull in their own dependencies (`wikipedia`, `youtube-search`, `google-search-results`). Install just the extras a page uses and set the matching API keys before running, so agents fail fast on config rather than mid-run.
  </Accordion>
</AccordionGroup>

***

## Related

<CardGroup cols={2}>
  <Card title="Custom Tools" icon="wrench" href="/docs/tools/custom">
    Build your own agent tools
  </Card>

  <Card title="Tools Overview" icon="toolbox" href="/docs/tools/tools">
    Browse PraisonAI tool documentation
  </Card>
</CardGroup>