ToolAgents 0.0.1__tar.gz

toolagents-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Maximilian Winter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

toolagents-0.0.1/PKG-INFO

@@ -0,0 +1,199 @@
+Metadata-Version: 2.1
+Name: ToolAgents
+Version: 0.0.1
+Summary: ToolAgents is a lightweight and flexible framework for creating function-calling agents with various language models and APIs.
+Author-email: Maximilian Winter <maximilian.winter.91@gmail.com>
+Project-URL: Homepage, https://github.com/Maximilian-Winter/ToolAgents
+Project-URL: Bug Tracker, https://github.com/Maximilian-Winter/ToolAgents/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.5.3
+Requires-Dist: requests>=2.31.0
+Requires-Dist: docstring_parser
+Requires-Dist: aiohttp
+Requires-Dist: mistral-common
+Requires-Dist: openai
+Requires-Dist: transformers
+Requires-Dist: sentencepiece
+Requires-Dist: protobuf
+Requires-Dist: anthropic
+Requires-Dist: ollama
+Requires-Dist: groq
+
+# ToolAgents
+
+ToolAgents is a lightweight and flexible framework for creating function-calling agents with various language models and APIs. It provides a unified interface for integrating different LLM providers and executing function calls seamlessly.
+
+## Features
+
+- Support for multiple LLM providers:
+    - llama.cpp servers
+    - Hugging Face's Text Generation Interface (TGI) servers
+    - vLLM servers
+    - OpenAI API
+    - Anthropic API
+    - Ollama (with Tool calling support)
+- Easy-to-use interface for passing functions, Pydantic models, and tools to LLMs
+- Streamlined process for function calling and result handling
+- Flexible agent types:
+    - MistralAgent for llama.cpp, TGI, and vLLM servers
+    - ChatAPIAgent for OpenAI and Anthropic APIs
+    - OllamaAgent for Ollama integration
+
+## Installation
+
+
+```bash
+pip install toolagents
+```
+
+## Usage
+
+### MistralAgent with llama.cpp Server
+
+```python
+from ToolAgents.agents import MistralAgent
+from ToolAgents.provider import LlamaCppServerProvider, LlamaCppSamplingSettings
+from ToolAgents.tests.test_tools import calculator_function_tool, current_datetime_function_tool, get_weather_function_tool
+
+# Initialize the provider and agent
+provider = LlamaCppServerProvider("http://127.0.0.1:8080/")
+agent = MistralAgent(llm_provider=provider, debug_output=False,
+                     system_prompt="You are a helpful assistant.")
+
+# Configure settings
+settings = LlamaCppSamplingSettings()
+settings.temperature = 0.3
+settings.top_p = 1.0
+settings.max_tokens = 4096
+
+# Define tools
+tools = [calculator_function_tool, current_datetime_function_tool, get_weather_function_tool]
+
+# Get a response
+result = agent.get_streaming_response(
+    "Perform the following tasks: Get the current weather in Celsius in London, New York, and at the North Pole. "
+    "Solve these calculations: 42 * 42, 74 + 26, 7 * 26, 4 + 6, and 96/8.",
+    sampling_settings=settings,
+    tools=tools
+)
+
+for token in result:
+    print(token, end="", flush=True)
+print()
+```
+
+### ChatAPIAgent with Anthropic API
+
+```python
+import os
+from dotenv import load_dotenv
+from ToolAgents.agents import ChatAPIAgent
+from ToolAgents.provider import AnthropicChatAPI, AnthropicSettings
+from ToolAgents.tests.test_tools import calculator_function_tool, current_datetime_function_tool, get_weather_function_tool
+
+load_dotenv()
+
+# Initialize the API and agent
+api = AnthropicChatAPI(api_key=os.getenv("ANTHROPIC_API_KEY"), model="claude-3-sonnet-20240229")
+agent = ChatAPIAgent(chat_api=api, system_prompt="You are a helpful assistant.")
+
+# Configure settings
+settings = AnthropicSettings()
+settings.temperature = 0.45
+settings.top_p = 0.85
+
+# Define tools
+tools = [calculator_function_tool, current_datetime_function_tool, get_weather_function_tool]
+
+# Get a response
+result = agent.get_response(
+    "Perform the following tasks: Get the current weather in Celsius in London, New York, and at the North Pole. "
+    "Solve these calculations: 42 * 42, 74 + 26, 7 * 26, 4 + 6, and 96/8.",
+    tools=tools,
+    settings=settings
+)
+
+print(result)
+```
+
+### OllamaAgent
+
+```python
+from ToolAgents.agents import OllamaAgent
+from ToolAgents.tests.test_tools import get_flight_times_tool
+
+def run():
+    agent = OllamaAgent(model='mistral-nemo', system_prompt="You are a helpful assistant.", debug_output=False)
+
+    tools = [get_flight_times_tool]
+
+    response = agent.get_response(
+        message="What is the flight time from New York (NYC) to Los Angeles (LAX)?",
+        tools=tools,
+    )
+
+    print(response)
+
+    print("\nStreaming response:")
+    for chunk in agent.get_streaming_response(
+            message="What is the flight time from London (LHR) to New York (JFK)?",
+            tools=tools,
+    ):
+        print(chunk, end='', flush=True)
+
+if __name__ == "__main__":
+    run()
+```
+
+## Custom Tools
+
+You can create custom tools using Pydantic models or function definitions. Here's an example of a custom calculator tool:
+
+```python
+from enum import Enum
+from typing import Union
+
+from pydantic import BaseModel, Field
+from ToolAgents import FunctionTool
+
+class MathOperation(Enum):
+    ADD = "add"
+    SUBTRACT = "subtract"
+    MULTIPLY = "multiply"
+    DIVIDE = "divide"
+
+class Calculator(BaseModel):
+    """
+    Perform a math operation on two numbers.
+    """
+    number_one: Union[int, float] = Field(..., description="First number.")
+    operation: MathOperation = Field(..., description="Math operation to perform.")
+    number_two: Union[int, float] = Field(..., description="Second number.")
+
+    def run(self):
+        if self.operation == MathOperation.ADD:
+            return self.number_one + self.number_two
+        elif self.operation == MathOperation.SUBTRACT:
+            return self.number_one - self.number_two
+        elif self.operation == MathOperation.MULTIPLY:
+            return self.number_one * self.number_two
+        elif self.operation == MathOperation.DIVIDE:
+            return self.number_one / self.number_two
+        else:
+            raise ValueError("Unknown operation.")
+
+calculator_tool = FunctionTool(Calculator)
+```
+
+## Contributing
+
+Contributions to ToolAgents are welcome! Please feel free to submit pull requests, create issues, or suggest improvements.
+
+## License
+
+ToolAgents is released under the MIT License. See the [LICENSE](LICENSE) file for details.

toolagents-0.0.1/ReadMe.md

@@ -0,0 +1,173 @@
+# ToolAgents
+
+ToolAgents is a lightweight and flexible framework for creating function-calling agents with various language models and APIs. It provides a unified interface for integrating different LLM providers and executing function calls seamlessly.
+
+## Features
+
+- Support for multiple LLM providers:
+    - llama.cpp servers
+    - Hugging Face's Text Generation Interface (TGI) servers
+    - vLLM servers
+    - OpenAI API
+    - Anthropic API
+    - Ollama (with Tool calling support)
+- Easy-to-use interface for passing functions, Pydantic models, and tools to LLMs
+- Streamlined process for function calling and result handling
+- Flexible agent types:
+    - MistralAgent for llama.cpp, TGI, and vLLM servers
+    - ChatAPIAgent for OpenAI and Anthropic APIs
+    - OllamaAgent for Ollama integration
+
+## Installation
+
+
+```bash
+pip install toolagents
+```
+
+## Usage
+
+### MistralAgent with llama.cpp Server
+
+```python
+from ToolAgents.agents import MistralAgent
+from ToolAgents.provider import LlamaCppServerProvider, LlamaCppSamplingSettings
+from ToolAgents.tests.test_tools import calculator_function_tool, current_datetime_function_tool, get_weather_function_tool
+
+# Initialize the provider and agent
+provider = LlamaCppServerProvider("http://127.0.0.1:8080/")
+agent = MistralAgent(llm_provider=provider, debug_output=False,
+                     system_prompt="You are a helpful assistant.")
+
+# Configure settings
+settings = LlamaCppSamplingSettings()
+settings.temperature = 0.3
+settings.top_p = 1.0
+settings.max_tokens = 4096
+
+# Define tools
+tools = [calculator_function_tool, current_datetime_function_tool, get_weather_function_tool]
+
+# Get a response
+result = agent.get_streaming_response(
+    "Perform the following tasks: Get the current weather in Celsius in London, New York, and at the North Pole. "
+    "Solve these calculations: 42 * 42, 74 + 26, 7 * 26, 4 + 6, and 96/8.",
+    sampling_settings=settings,
+    tools=tools
+)
+
+for token in result:
+    print(token, end="", flush=True)
+print()
+```
+
+### ChatAPIAgent with Anthropic API
+
+```python
+import os
+from dotenv import load_dotenv
+from ToolAgents.agents import ChatAPIAgent
+from ToolAgents.provider import AnthropicChatAPI, AnthropicSettings
+from ToolAgents.tests.test_tools import calculator_function_tool, current_datetime_function_tool, get_weather_function_tool
+
+load_dotenv()
+
+# Initialize the API and agent
+api = AnthropicChatAPI(api_key=os.getenv("ANTHROPIC_API_KEY"), model="claude-3-sonnet-20240229")
+agent = ChatAPIAgent(chat_api=api, system_prompt="You are a helpful assistant.")
+
+# Configure settings
+settings = AnthropicSettings()
+settings.temperature = 0.45
+settings.top_p = 0.85
+
+# Define tools
+tools = [calculator_function_tool, current_datetime_function_tool, get_weather_function_tool]
+
+# Get a response
+result = agent.get_response(
+    "Perform the following tasks: Get the current weather in Celsius in London, New York, and at the North Pole. "
+    "Solve these calculations: 42 * 42, 74 + 26, 7 * 26, 4 + 6, and 96/8.",
+    tools=tools,
+    settings=settings
+)
+
+print(result)
+```
+
+### OllamaAgent
+
+```python
+from ToolAgents.agents import OllamaAgent
+from ToolAgents.tests.test_tools import get_flight_times_tool
+
+def run():
+    agent = OllamaAgent(model='mistral-nemo', system_prompt="You are a helpful assistant.", debug_output=False)
+
+    tools = [get_flight_times_tool]
+
+    response = agent.get_response(
+        message="What is the flight time from New York (NYC) to Los Angeles (LAX)?",
+        tools=tools,
+    )
+
+    print(response)
+
+    print("\nStreaming response:")
+    for chunk in agent.get_streaming_response(
+            message="What is the flight time from London (LHR) to New York (JFK)?",
+            tools=tools,
+    ):
+        print(chunk, end='', flush=True)
+
+if __name__ == "__main__":
+    run()
+```
+
+## Custom Tools
+
+You can create custom tools using Pydantic models or function definitions. Here's an example of a custom calculator tool:
+
+```python
+from enum import Enum
+from typing import Union
+
+from pydantic import BaseModel, Field
+from ToolAgents import FunctionTool
+
+class MathOperation(Enum):
+    ADD = "add"
+    SUBTRACT = "subtract"
+    MULTIPLY = "multiply"
+    DIVIDE = "divide"
+
+class Calculator(BaseModel):
+    """
+    Perform a math operation on two numbers.
+    """
+    number_one: Union[int, float] = Field(..., description="First number.")
+    operation: MathOperation = Field(..., description="Math operation to perform.")
+    number_two: Union[int, float] = Field(..., description="Second number.")
+
+    def run(self):
+        if self.operation == MathOperation.ADD:
+            return self.number_one + self.number_two
+        elif self.operation == MathOperation.SUBTRACT:
+            return self.number_one - self.number_two
+        elif self.operation == MathOperation.MULTIPLY:
+            return self.number_one * self.number_two
+        elif self.operation == MathOperation.DIVIDE:
+            return self.number_one / self.number_two
+        else:
+            raise ValueError("Unknown operation.")
+
+calculator_tool = FunctionTool(Calculator)
+```
+
+## Contributing
+
+Contributions to ToolAgents are welcome! Please feel free to submit pull requests, create issues, or suggest improvements.
+
+## License
+
+ToolAgents is released under the MIT License. See the [LICENSE](LICENSE) file for details.

toolagents-0.0.1/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = [  "setuptools>=42"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ToolAgents"
+version = "0.0.1"
+description = "ToolAgents is a lightweight and flexible framework for creating function-calling agents with various language models and APIs."
+
+readme = "ReadMe.md"
+dependencies = [
+    "pydantic>=2.5.3",
+    "requests>=2.31.0",
+    "docstring_parser",
+    "aiohttp",
+    "mistral-common",
+    "openai",
+    "transformers",
+    "sentencepiece",
+    "protobuf",
+    "anthropic",
+    "ollama",
+    "groq"
+]
+
+requires-python = ">=3.10"
+classifiers = [ "Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent" ]
+[[project.authors]]
+name = "Maximilian Winter"
+email = "maximilian.winter.91@gmail.com"
+
+
+[project.urls]
+Homepage = "https://github.com/Maximilian-Winter/ToolAgents"
+"Bug Tracker" = "https://github.com/Maximilian-Winter/ToolAgents/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+

toolagents-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

toolagents-0.0.1/src/ToolAgents/__init__.py

@@ -0,0 +1,2 @@
+from .function_tool import FunctionTool
+

toolagents-0.0.1/src/ToolAgents/agents/__init__.py

@@ -0,0 +1,3 @@
+from ToolAgents.agents.chat_api_agent import ChatAPIAgent
+from ToolAgents.agents.mistral_agent import MistralAgent
+from ToolAgents.agents.ollama_agent import OllamaAgent

toolagents-0.0.1/src/ToolAgents/agents/chat_api_agent.py

@@ -0,0 +1,180 @@
+import json
+import random
+import string
+from typing import Optional, Dict, List, Any
+
+from ToolAgents import FunctionTool
+from ToolAgents.provider.chat_api_with_tools import ChatAPI
+
+
+def generate_id(length=8):
+    # Characters to use in the ID
+    characters = string.ascii_letters + string.digits
+    # Random choice of characters
+    return "".join(random.choice(characters) for _ in range(length))
+
+
+class ChatAPIAgent:
+    def __init__(
+            self,
+            chat_api: ChatAPI,
+            system_prompt: Optional[str] = None,
+            debug_output: bool = False,
+    ):
+        self.chat_api = chat_api
+        self.messages: List[Dict[str, Any]] = []
+        self.debug_output = debug_output
+        self.system_prompt = system_prompt
+
+        if system_prompt is not None:
+            self.messages.append({"role": "system", "content": system_prompt})
+
+    def get_response(
+            self,
+            message: Optional[str] = None,
+            tools: Optional[List[FunctionTool]] = None,
+            settings: Optional[Any] = None,
+            messages: Optional[List[Dict[str, Any]]] = None,
+            override_system_prompt: Optional[str] = None,
+    ) -> str:
+        if tools is None:
+            tools = []
+
+        # Use provided messages if available, otherwise use internal messages
+        current_messages = messages if messages is not None else self.messages.copy()
+
+        # Override system prompt if provided
+        if override_system_prompt is not None:
+            current_messages = [msg for msg in current_messages if msg["role"] != "system"]
+            current_messages.insert(0, {"role": "system", "content": override_system_prompt})
+        elif self.system_prompt is not None and not any(msg["role"] == "system" for msg in current_messages):
+            current_messages.insert(0, {"role": "system", "content": self.system_prompt})
+
+        if message is not None:
+            current_messages.append({"role": "user", "content": message})
+
+        if self.debug_output:
+            print("Input messages:", json.dumps(current_messages, indent=2))
+
+        result = self.chat_api.get_response(current_messages, settings=settings, tools=tools)
+
+        try:
+            parsed_result = json.loads(result)
+            if "tool_calls" in parsed_result:
+                tool_calls = parsed_result["tool_calls"]
+                content = parsed_result.get("content", "")
+
+                tool_calls_prepared = []
+                tool_messages = []
+                for tool_call in tool_calls:
+                    tool = next((t for t in tools if t.model.__name__ == tool_call["function"]["name"]), None)
+                    if tool:
+                        call_parameters = tool_call["function"]["arguments"]
+                        if isinstance(call_parameters, str):
+                            call_parameters = json.loads(call_parameters)
+                        call = tool.model(**call_parameters)
+                        output = call.run(**tool.additional_parameters)
+                        tool_call_id = tool_call["function"].get("id", tool_call.get("id", generate_id(length=9)))
+                        tool_calls_prepared.append(
+                            self.chat_api.generate_tool_use_message(content=parsed_result["content"],
+                                                                    tool_call_id=tool_call_id,
+                                                                    tool_name=tool_call["function"]["name"],
+                                                                    tool_args=call_parameters))
+                        tool_messages.append(
+                            self.chat_api.generate_tool_response_message(
+                                tool_call_id=tool_call_id,
+                                tool_name=tool_call["function"]["name"],
+                                tool_response=str(output)
+                            )
+                        )
+                if "role" in tool_calls_prepared[0]:
+                    current_messages.extend(tool_calls_prepared)
+                else:
+                    current_messages.append(
+                        {"role": "assistant", "content": parsed_result["content"], "tool_calls": tool_calls_prepared})
+                current_messages.extend(tool_messages)
+                return self.get_response(settings=settings, tools=tools, messages=current_messages)
+            else:
+                current_messages.append({"role": "assistant", "content": result})
+                return result
+        except json.JSONDecodeError:
+            current_messages.append({"role": "assistant", "content": result})
+            return result
+
+    def get_streaming_response(
+            self,
+            message: Optional[str] = None,
+            tools: Optional[List[FunctionTool]] = None,
+            settings: Optional[Any] = None,
+            messages: Optional[List[Dict[str, Any]]] = None,
+            override_system_prompt: Optional[str] = None,
+    ):
+        if tools is None:
+            tools = []
+
+        # Use provided messages if available, otherwise use internal messages
+        current_messages = messages if messages is not None else self.messages.copy()
+
+        # Override system prompt if provided
+        if override_system_prompt is not None:
+            current_messages = [msg for msg in current_messages if msg["role"] != "system"]
+            current_messages.insert(0, {"role": "system", "content": override_system_prompt})
+        elif self.system_prompt is not None and not any(msg["role"] == "system" for msg in current_messages):
+            current_messages.insert(0, {"role": "system", "content": self.system_prompt})
+
+        if message is not None:
+            current_messages.append({"role": "user", "content": message})
+
+        if self.debug_output:
+            print("Input messages:", json.dumps(current_messages, indent=2))
+
+        for chunk in self.chat_api.get_streaming_response(current_messages, settings=settings, tools=tools):
+            yield chunk
+
+        # After streaming is complete, update the message history
+        last_message = {"role": "assistant", "content": ""}
+        for chunk in self.chat_api.get_streaming_response(current_messages, settings=settings, tools=tools):
+            try:
+                parsed_chunk = json.loads(chunk)
+                if "tool_calls" in parsed_chunk:
+                    last_message["tool_calls"] = parsed_chunk["tool_calls"]
+                    if parsed_chunk.get("content"):
+                        last_message["content"] += parsed_chunk["content"]
+                else:
+                    last_message["content"] += chunk
+            except json.JSONDecodeError:
+                last_message["content"] += chunk
+
+        if "tool_calls" in last_message:
+            tool_messages = []
+            tool_calls_prepared = []
+            for tool_call in last_message["tool_calls"]:
+                tool = next((t for t in tools if t.model.__name__ == tool_call["function"]["name"]), None)
+                if tool:
+                    call_parameters = tool_call["function"]["arguments"]
+                    if isinstance(call_parameters, str):
+                        call_parameters = json.loads(call_parameters)
+                    call = tool.model(**call_parameters)
+                    output = call.run(**tool.additional_parameters)
+                    tool_call_id = tool_call["function"].get("id", generate_id(length=9))
+                    tool_calls_prepared.append(
+                        self.chat_api.generate_tool_use_message(content=last_message["content"],
+                                                                tool_call_id=tool_call_id,
+                                                                tool_name=tool_call["function"]["name"],
+                                                                tool_args=call_parameters))
+                    tool_messages.append(
+                        self.chat_api.generate_tool_response_message(
+                            tool_call_id=tool_call_id,
+                            tool_name=tool_call["function"]["name"],
+                            tool_response=str(output)
+                        )
+                    )
+            if "role" in tool_calls_prepared[0]:
+                current_messages.extend(tool_calls_prepared)
+            else:
+                current_messages.append(
+                    {"role": "assistant", "content": last_message["content"], "tool_calls": tool_calls_prepared})
+
+            current_messages.extend(tool_messages)
+            yield "\n"
+            yield from self.get_streaming_response(settings=settings, tools=tools, messages=current_messages)