🤖 Create Agents in a Second - with the Best Tools, RAG, Knowledge Graph and Vector Databases

📑 Table of Contents

• Introduction
• Architecture
• Installation
• Usage
  • Package Version
  • Python Interface
  • Source Code Version
• DemoGPT AgentHub
  • Installation
  • Creating Tools
  • Available Tools
  • Creating an Agent
  • Using an Agent
  • Available Agent Types
  • Using ReactAgent
  • Using RAG
  • Combining RAG with Agents
• To-Do
• Contribute
• Citations
• License

🤖 DemoGPT AgentHub

DemoGPT AgentHub is a powerful library that allows you to create, customize, and use AI agents with various tools.

🛠 Installation

To use DemoGPT AgentHub, simply install the main package:

pip install demogpt

🔧 Creating Tools

Creating custom tools is easy:

from demogpt_agenthub.tools import BaseTool
class MyCustomTool(BaseTool):
    def __init__(self):
        self.name = "MyCustomTool"
        self.description = "This tool does something amazing!"
        super().__init__()
    def run(self, query):
        # Implement your tool's functionality here
        return f"Result for: {query}"

Example Usage:

my_tool = MyCustomTool()
agent = ToolCallingAgent(tools=[my_tool], llm=llm, verbose=True)
agent.run("Can you use my custom tool?")

Example Output:

Reasoning:
The user is asking to use the custom tool called MyCustomTool. This tool is described as doing "something amazing", so I will use it to process the query.
Tool call:
MyCustomTool
Tool result:
Result for: Can you use my custom tool?
Answer:
Yes, I successfully used your custom tool! The tool processed your query and returned the following result: "Result for: Can you use my custom tool?"

🧰 Available Tools

DemoGPT AgentHub comes with several built-in tools:

• 🔍 TavilySearchTool
• 🌦 WeatherTool
• 📚 WikipediaTool
• 🐚 BashTool
• 🐍 PythonTool
• 📄 ArxivTool
• 🎥 YouTubeSearchTool
• 💻 StackOverFlowTool
• 🌐 RequestUrlTool
• 🗃 WikiDataTool
• 🏥 PubmedTool

🤖 Creating an Agent

To create an agent:

from demogpt_agenthub.agents import ToolCallingAgent
from demogpt_agenthub.llms import OpenAIChatModel
from demogpt_agenthub.tools import TavilySearchTool, WeatherTool

search_tool = TavilySearchTool()
weather_tool = WeatherTool()
llm = OpenAIChatModel(model_name="gpt-4o-mini")
agent = ToolCallingAgent(tools=[search_tool, weather_tool], llm=llm, verbose=True)

🎮 Using an Agent

Once you've created an agent, use it to ask questions or perform tasks:

query = "What's the weather like in New York today?"
response = agent.run(query)
print(response)

Example Output:

Removing existing vectorstore at rag_chroma
Decision:
False
Reasoning:
To find the weather in New York today, I first need to retrieve the current weather information. After obtaining the weather information, I can provide you with the current weather conditions. The RAG tool will help me find out the current weather in New York.
Tool call:
RAG
Tool args:
{'query': 'weather in New York today'}
Tool result:
In New York, the current weather is as follows:
Detailed status: clear sky
Wind speed: 2.57 m/s, direction: 240°
Humidity: 56%
Temperature: 
  - Current: 24.36°C
  - High: 25.74°C
  - Low: 22.05°C
  - Feels like: 24.46°C
Rain: {}
Heat index: None
Cloud cover: 0%
Answer:
The current weather in New York is clear sky with a temperature of 24.36°C (feels like 24.46°C). The humidity is at 56% with a wind speed of 2.57 m/s from the direction of 240°. There is 0% cloud cover.

This example demonstrates how an agent can:

1. Access document information through RAG
2. Use Python for calculations
3. Combine multiple tools to answer complex questions

The agent will:

1. Use RAG to find information about the current weather in New York
2. Use the Python tool to calculate the current weather conditions
3. Provide a comprehensive answer using both pieces of information

🧰 Example: Creating a Simple Math Tool

Here's an example of creating a custom power calculation tool:

from demogpt_agenthub.tools import BaseTool
class MyPowerTool(BaseTool):
    def __init__(self):
        self.name = "MyPowerTool"
        self.description = "This tool is used to calculate the power of a number"
        super().__init__()
    def run(self, a: int, b: int):
        # Implement your tool's functionality here
        return a**b

power_tool = MyPowerTool()
agent = ToolCallingAgent(tools=[search_tool, weather_tool, power_tool], llm=llm, verbose=True)
agent.run("What is the 34 to the power of 26?")

Example Output:

Reasoning:
The task is to calculate a number raised to the power of another. The most appropriate tool for this calculation is MyPowerTool, which is specifically designed for power calculations.
Tool call:
MyPowerTool
Tool result:
6583424253569334549714045134721532297216
Answer:
34 to the power of 26 is 6583424253569334549714045134721532297216.

🧠 Using ReactAgent

The ReactAgent provides a detailed reasoning process:

Example 1: Weather and Math Calculations

from demogpt_agenthub.tools import TavilySearchTool, WeatherTool, PythonTool
from demogpt_agenthub.llms import OpenAIChatModel
from demogpt_agenthub.agents import ReactAgent

search_tool = TavilySearchTool()
weather_tool = WeatherTool()
python_tool = PythonTool()

agent = ReactAgent(
    tools=[search_tool, weather_tool, python_tool],
    llm=OpenAIChatModel(model_name="gpt-4o-mini"),
    verbose=True
)

query = "What is the weather's temperature's square root in the country where Cristiano Ronaldo is currently playing?"
print(agent.run(query))

Example Output:

Decision:
False
Reasoning:
First, I need to determine the current location where Christiano Ronaldo is playing in order to fetch the current temperature. Then I will use the OpenWeatherMap tool to get the temperature information. Finally, I will calculate the square root of the temperature using the Python Interpreter tool for precise computation.
Tool call:
duckduckgo_search
Tool args:
{'inp': 'Where is Christiano Ronaldo currently playing?'}
Tool result:
Ronaldo started Al Nassr's home match against Saudi Pro League leaders Al Ittihad on