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

# Different Ways to Create Tools

> Explore all methods for creating tools in PraisonAI

## How to Create Tools as Functions

<Steps>
  <Step title="Define Simple Function">
    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    def calculator_tool(expression: str) -> float:
        """Evaluate a mathematical expression.
        
        Args:
            expression: Math expression to evaluate
            
        Returns:
            Result of the calculation
        """
        return eval(expression)
    ```
  </Step>

  <Step title="Use with Agent">
    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    from praisonaiagents import Agent

    agent = Agent(
        name="calculator",
        tools=[calculator_tool]
    )
    ```
  </Step>
</Steps>

## How to Create Tools as Lambda Functions

<Steps>
  <Step title="Define Lambda Tool">
    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    # Simple lambda tool
    uppercase_tool = lambda text: text.upper()
    uppercase_tool.__doc__ = "Convert text to uppercase"
    uppercase_tool.__annotations__ = {"text": str, "return": str}
    ```
  </Step>

  <Step title="Use with Agent">
    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    agent = Agent(
        name="formatter",
        tools=[uppercase_tool]
    )
    ```
  </Step>
</Steps>

## How to Create Tools from External Libraries

<Steps>
  <Step title="Wrap Library Function">
    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    import requests

    def http_get_tool(url: str) -> dict:
        """Make HTTP GET request.
        
        Args:
            url: URL to fetch
            
        Returns:
            Response data as dictionary
        """
        response = requests.get(url)
        return {
            "status": response.status_code,
            "content": response.text[:1000]
        }
    ```
  </Step>

  <Step title="Use Wrapped Tool">
    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    agent = Agent(
        name="http_agent",
        tools=[http_get_tool]
    )
    ```
  </Step>
</Steps>

## How to Create Tools in tools.py File

<Steps>
  <Step title="Create tools.py">
    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    # tools.py

    def file_reader(path: str) -> str:
        """Read file contents.
        
        Args:
            path: Path to file
            
        Returns:
            File contents
        """
        with open(path, 'r') as f:
            return f.read()

    def file_writer(path: str, content: str) -> bool:
        """Write content to file.
        
        Args:
            path: Path to file
            content: Content to write
            
        Returns:
            Success status
        """
        with open(path, 'w') as f:
            f.write(content)
        return True
    ```
  </Step>

  <Step title="Reference in Template">
    ```yaml theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    # agents.yaml
    roles:
      file_agent:
        tools:
          - file_reader
          - file_writer
    ```
  </Step>
</Steps>

## How to Create Tools in a Package

<Steps>
  <Step title="Create Package Structure">
    ```
    my_tools/
    ├── __init__.py
    ├── search.py
    └── database.py
    ```
  </Step>

  <Step title="Define Tools in Module">
    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    # my_tools/search.py

    def web_search(query: str) -> list:
        """Search the web.
        
        Args:
            query: Search query
            
        Returns:
            List of results
        """
        return [{"title": "Result", "url": "https://example.com"}]
    ```
  </Step>

  <Step title="Export in __init__.py">
    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    # my_tools/__init__.py
    from .search import web_search
    from .database import db_query

    __all__ = ["web_search", "db_query"]
    ```
  </Step>

  <Step title="Use as tools_source">
    ```yaml theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    # TEMPLATE.yaml
    requires:
      tools_sources:
        - my_tools
    ```
  </Step>
</Steps>

## How to Create Tools with Decorators

<Steps>
  <Step title="Use Tool Decorator">
    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    from praisonaiagents import tool

    @tool
    def decorated_tool(query: str) -> str:
        """A decorated tool function.
        
        Args:
            query: Input query
            
        Returns:
            Processed result
        """
        return f"Processed: {query}"
    ```
  </Step>

  <Step title="Use with Agent">
    ```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    agent = Agent(
        name="decorated_agent",
        tools=[decorated_tool]
    )
    ```
  </Step>
</Steps>

## How to Add Tools via CLI

<Steps>
  <Step title="Add Package Tools">
    ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    praisonai tools add pandas
    ```
  </Step>

  <Step title="Add Local File">
    ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    praisonai tools add ./my_tools.py
    ```
  </Step>

  <Step title="Add from GitHub">
    ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    praisonai tools add github:user/repo/tools
    ```
  </Step>

  <Step title="Verify Added Tools">
    ```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
    praisonai tools list
    ```
  </Step>
</Steps>

## Tool Creation Methods Comparison

| Method        | Best For            | Complexity |
| ------------- | ------------------- | ---------- |
| Function      | Simple tools        | Low        |
| Lambda        | One-liners          | Low        |
| Class         | Stateful tools      | Medium     |
| Package       | Reusable tools      | Medium     |
| Decorator     | Enhanced tools      | Low        |
| External wrap | Library integration | Medium     |
| CLI add       | Quick setup         | Low        |