Learning Agno with Math (Help me understand and fix)

[gafda]

Hi all! I'm trying to learn how to create my very own tools using math methods. The objective is to use either requests or httpx to do custom API calls, but for now I'm using simple math to figure out how Agno works.
That said, I've created a class with basic math methods and an agent that is able to call it.
What I've observed is that it spends a bunch of tokens for a simple math call.

Why is that?
Below you can see that a simple prompt of 2 times 10 uses almost 1000 tokens!

Using:

• Python 3.12.3
• Agno 1.1.13
• gpt-4o-mini

Math calls: generic_calls.py

class Generic:
    def add(self, a: int, b: int) -> int:
        """Adds two numbers.

        Args:
            a (int): First number.
            b (int): Second number.

        Returns:
            int: The sum of a and b.
        """
        return a + b

    def subtract(self, a: int, b: int) -> int:
        """Subtracts two numbers.

        Args:
            a (int): First number.
            b (int): Second number.

        Returns:
            int: The subtraction of b from a.
        """
        return a - b

    def multiply(self, a: int, b: int) -> int:
        """Multiplies two numbers.

        Args:
            a (int): First number.
            b (int): Second number.

        Returns:
            int: The multiplication of a and b.
        """
        return a * b

    def divide(self, a: int, b: int) -> float:
        """Divides two numbers.

        Args:
            a (int): First number.
            b (int): Second number.

        Returns:
            float: The division of a by b.
        """
        return a / b

Abstract BaseAgent: base_agent.py

from typing import Tuple
from abc import abstractmethod
from backend.settings import settings

class BaseAgent:
    name: str = "Base Agent"
    framework: str

    def __init__(self, model = None):
        """
        Initialize the LangGraph agent using create_react_agent.
        """
        self.model = model

        if self.model == None:
            raise ValueError("No LLM provider was selected or the API key is missing.")

        self.tools = self.create_tools()
        self.agent = self.create_agent()

        self.name_slug = self.name.lower().replace(' ', '_')
        self.chat_endpoint = f"/chat/{self.name_slug}"

    @abstractmethod
    def create_tools(self) -> list:
        """
        Create tools for the agent.

        Returns:
            List of tools
        """
        pass

    @abstractmethod
    def set_tuples_tool_description(self) -> list[Tuple[str, str]]:
        pass

    def get_tools_descriptions(self) -> str:
        """
        Generates a formatted string with the tools and their descriptions.
        """
        tools_tuples = self.set_tuples_tool_description()
        return f"{'\n\n'.join(f'- {tool} ({desc})' for tool, desc in tools_tuples)}"

    @abstractmethod
    def create_agent(self) -> any:
        """
        Create the agent.
        
        Returns:
            The agent.
        """
        pass

    # ------------
    # Chat Methods
    # ------------
    @abstractmethod
    async def chat_stream(self, input: str):
        pass

    @abstractmethod
    async def chat_no_stream(self, input: str):
        pass

    @abstractmethod
    async def chat_all_messages(self, input: str):
        pass

Agent: my_agent.py

from typing import Tuple

from agno.agent import Agent, RunResponse
from agno.models.openai import OpenAIChat, OpenAILike
from agno.models.azure import AzureOpenAI

from backend.agents.agent import BaseAgent
from backend.settings import settings
from backend.agents.shared_functions import Generic

class MyAgent(BaseAgent):
    name: str = "Agno Fuction Calling Agent"
    framework: str = "Agno"
    __TEMPERATURE: float = 0.0
    __DEBUG: bool = True

    def __init__(self, llm_provider: str = "azure"):
        model: any = None

        if llm_provider == "azure" and settings.azure_api_key:
            model = AzureOpenAI(
                base_url=f"{settings.azure_endpoint}/deployments/{settings.azure_deployment_name}",
                api_key=settings.azure_api_key.get_secret_value(),
                api_version=settings.azure_api_version,
                id=settings.azure_deployment_name,
                temperature=self.__TEMPERATURE,
            )

        if llm_provider == "openai" and settings.openai_api_key:
            model = OpenAIChat(
                api_key=settings.openai_api_key.get_secret_value(),
                id=settings.openai_model_name,
                temperature=self.__TEMPERATURE,
            )

        super().__init__(model=model)
        self.thread_id = 1

    def create_tools(self) -> list:
        return [
            Generic.add,
            Generic.subtract,
            Generic.multiply,
            Generic.divide,
        ]

    def set_tuples_tool_description(self) -> list[Tuple[str, str]]:
        return [(tool.metadata.name, tool.metadata.description) for tool in self.tools]

    def create_agent(self):
        return Agent(
            debug_mode=self.__DEBUG,
            model=self.model,
            tools=self.tools,
            markdown=True,
            show_tool_calls=True,
            telemetry=False,
        )

    async def chat_stream(self, input):
        response: RunResponse = self.agent.run(input, stream=True)

        for chunk in response:
            yield chunk.content

    async def chat_no_stream(self, input: str):
        response: RunResponse = self.agent.run(input, stream=False)

        return response.content

    async def chat_all_messages(self, input):
        response: RunResponse = self.agent.run(
            input,
            stream=False,
        )

        return response.content

async def main():
    agent = MyAgent()

    while True:
        query = input("You: ")
        if query.lower() in ['exit', 'quit']:
            break

        message: str = await agent.chat_all_messages(query)
        print(message)

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

[ysolanky]

Hello @gafda ! The tools that you define are a part of the input tokens. I'd recommend you to try: https://docs.agno.com/tools/toolkits/calculator. In my testing, the token usage is not as high - but that of course depends upon your query and Agent instructions. Additionally, token usage is highly dependent upon whether or not your provide the Agent with chat history by setting: add_history_to_messages=True. Do let us know if you have any questions.

[gafda]

First of all, thank you for the rapid response!

I was trying to understand the bare minimum to create tools.
Thank you for your guidance as it helped me find the right way to do tooling for Agno (I believe).

So a few important notes that I've learned and I think should be highlighted in the Tools documentation as part of the quick starting guide:

• When not using the Toolkit class technique, then I've learned that the tool methods should NOT contain the 'self' argument. In my opinion, it would be better to declare those as 'static':

ie.:

class ToolsClass:

    @staticmethod
    def get_current_date() -> str:
        """Useful function to get the current date in the format "YYYY-MM-DD".

        Returns:
            str: The current date in the format "YYYY-MM-DD".
        """
        response = datetime.now(timezone.utc).strftime("%Y-%m-%d")

        return json.dumps({"operation": "current date", "result": response})

• The second thing that I've learned is that all tool methods MUST return a string and SHOULD be the result of the json.dumps(...). This was specially important to have the tool working! I "hit my head with this" 😄 for some time before figuring this out...

return json.dumps({"operation": "current date", "result": response})

[gafda]

How should I do it correctly (this last method) as a ToolKit?