tinyagent-py 0.0.1__tar.gz

tinyagent_py-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 askbudi
+
+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.

tinyagent_py-0.0.1/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: tinyagent-py
+Version: 0.0.1
+Summary: Tiny Agent with MCP Client
+Author-email: Mahdi Golchin <golchin@askdev.ai>
+License: MIT
+Project-URL: Homepage, https://github.com/askbudi/tinyagent
+Project-URL: Bug Tracker, https://github.com/askbudi/tinyagent/issues
+Project-URL: Chat, https://askdev.ai/github/askbudi/tinyagent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp
+Requires-Dist: litellm
+Requires-Dist: openai
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# tinyagent
+Tiny Agent: 100 lines Agent with MCP
+
+Inspired by:
+- [Tiny Agents blog post](https://huggingface.co/blog/tiny-agents)
+- [12-factor-agents repository](https://github.com/humanlayer/12-factor-agents)
+- Created by chatting to the source code of JS Tiny Agent using [AskDev.ai](https://askdev.ai/search)
+
+## Quick Links
+- [Build your own Tiny Agent](https://askdev.ai/github/askbudi/tinyagent)
+
+## Overview
+This is a tiny agent that uses MCP and LiteLLM to interact with a model. You have full control over the agent, you can add any tools you like from MCP and extend the agent using its event system.
+
+## Installation
+
+### Using pip
+```bash
+pip install tinyagent
+```
+
+### Using uv
+```bash
+uv pip install tinyagent
+```
+
+## Usage
+
+```python
+from tinyagent import TinyAgent
+from textwrap import dedent
+import asyncio
+import os
+
+async def test_agent(task, model="o4-mini", api_key=None):
+    # Initialize the agent with model and API key
+    agent = TinyAgent(
+        model=model,  # Or any model supported by LiteLLM
+        api_key=os.environ.get("OPENAI_API_KEY") if not api_key else api_key  # Set your API key as an env variable
+    )
+    
+    try:
+        # Connect to an MCP server
+        # Replace with your actual server command and args
+        await agent.connect_to_server("npx", ["@openbnb/mcp-server-airbnb", "--ignore-robots-txt"])
+        
+        # Run the agent with a user query
+        result = await agent.run(task)
+        print("\nFinal result:", result)
+        return result
+    finally:
+        # Clean up resources
+        await agent.close()
+
+# Example usage
+task = dedent("""
+I need accommodation in Toronto between 15th to 20th of May. Give me 5 options for 2 adults.
+""")
+await test_agent(task, model="gpt-4.1-mini")
+```

tinyagent_py-0.0.1/README.md

@@ -0,0 +1,60 @@
+# tinyagent
+Tiny Agent: 100 lines Agent with MCP
+
+Inspired by:
+- [Tiny Agents blog post](https://huggingface.co/blog/tiny-agents)
+- [12-factor-agents repository](https://github.com/humanlayer/12-factor-agents)
+- Created by chatting to the source code of JS Tiny Agent using [AskDev.ai](https://askdev.ai/search)
+
+## Quick Links
+- [Build your own Tiny Agent](https://askdev.ai/github/askbudi/tinyagent)
+
+## Overview
+This is a tiny agent that uses MCP and LiteLLM to interact with a model. You have full control over the agent, you can add any tools you like from MCP and extend the agent using its event system.
+
+## Installation
+
+### Using pip
+```bash
+pip install tinyagent
+```
+
+### Using uv
+```bash
+uv pip install tinyagent
+```
+
+## Usage
+
+```python
+from tinyagent import TinyAgent
+from textwrap import dedent
+import asyncio
+import os
+
+async def test_agent(task, model="o4-mini", api_key=None):
+    # Initialize the agent with model and API key
+    agent = TinyAgent(
+        model=model,  # Or any model supported by LiteLLM
+        api_key=os.environ.get("OPENAI_API_KEY") if not api_key else api_key  # Set your API key as an env variable
+    )
+    
+    try:
+        # Connect to an MCP server
+        # Replace with your actual server command and args
+        await agent.connect_to_server("npx", ["@openbnb/mcp-server-airbnb", "--ignore-robots-txt"])
+        
+        # Run the agent with a user query
+        result = await agent.run(task)
+        print("\nFinal result:", result)
+        return result
+    finally:
+        # Clean up resources
+        await agent.close()
+
+# Example usage
+task = dedent("""
+I need accommodation in Toronto between 15th to 20th of May. Give me 5 options for 2 adults.
+""")
+await test_agent(task, model="gpt-4.1-mini")
+```

tinyagent_py-0.0.1/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tinyagent-py"
+version = "0.0.1"
+description = "Tiny Agent with MCP Client"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+  {name="Mahdi Golchin", email="golchin@askdev.ai"}
+]
+requires-python = ">=3.8"
+dependencies = [
+  "mcp",
+  "litellm",
+  "openai"
+  # add whatever else you need…
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest",
+  
+  
+]
+[project.urls]
+"Homepage" = "https://github.com/askbudi/tinyagent"
+"Bug Tracker" = "https://github.com/askbudi/tinyagent/issues"
+"Chat" = "https://askdev.ai/github/askbudi/tinyagent"

tinyagent_py-0.0.1/setup.cfg

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

tinyagent_py-0.0.1/tinyagent/__init__.py

@@ -0,0 +1,4 @@
+from .tiny_agent import TinyAgent
+from .mcp_client import MCPClient
+
+__all__ = ["TinyAgent", "MCPClient"]

tinyagent_py-0.0.1/tinyagent/mcp_client.py

@@ -0,0 +1,52 @@
+import asyncio
+import json
+import logging
+from typing import Dict, List, Optional, Any, Tuple
+
+# Keep your MCPClient implementation unchanged
+import asyncio
+from contextlib import AsyncExitStack
+
+# MCP core imports
+from mcp import ClientSession, StdioServerParameters
+from mcp.client.stdio import stdio_client
+
+class MCPClient:
+    def __init__(self):
+        self.session = None
+        self.exit_stack = AsyncExitStack()
+
+    async def connect(self, command: str, args: list[str]):
+        """
+        Launches the MCP server subprocess and initializes the client session.
+        :param command: e.g. "python" or "node"
+        :param args: list of args to pass, e.g. ["my_server.py"] or ["build/index.js"]
+        """
+        # Prepare stdio transport parameters
+        params = StdioServerParameters(command=command, args=args)
+        # Open the stdio client transport
+        self.stdio, self.sock_write = await self.exit_stack.enter_async_context(
+            stdio_client(params)
+        )
+        # Create and initialize the MCP client session
+        self.session = await self.exit_stack.enter_async_context(
+            ClientSession(self.stdio, self.sock_write)
+        )
+        await self.session.initialize()
+
+    async def list_tools(self):
+        resp = await self.session.list_tools()
+        print("Available tools:")
+        for tool in resp.tools:
+            print(f" • {tool.name}: {tool.description}")
+
+    async def call_tool(self, name: str, arguments: dict):
+        """
+        Invokes a named tool and returns its raw content list.
+        """
+        resp = await self.session.call_tool(name, arguments)
+        return resp.content
+
+    async def close(self):
+        # Clean up subprocess and streams
+        await self.exit_stack.aclose()

tinyagent_py-0.0.1/tinyagent/tiny_agent.py

@@ -0,0 +1,247 @@
+# Import LiteLLM for model interaction
+import litellm
+import json
+import logging
+from typing import Dict, List, Optional, Any, Tuple
+from .mcp_client import MCPClient
+
+# Set up logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+#litellm.callbacks = ["arize_phoenix"]
+
+
+
+class TinyAgent:
+    """
+    A minimal implementation of an agent powered by MCP and LiteLLM.
+    This agent is literally just a while loop on top of MCPClient.
+    """
+    
+    def __init__(self, model: str = "gpt-4o", api_key: Optional[str] = None, system_prompt: Optional[str] = None):
+        """
+        Initialize the Tiny Agent.
+        
+        Args:
+            model: The model to use with LiteLLM
+            api_key: The API key for the model provider
+            system_prompt: Custom system prompt for the agent
+        """
+        # Create the MCPClient
+        self.mcp_client = MCPClient()
+        
+        # LiteLLM configuration
+        self.model = model
+        self.api_key = api_key
+        if api_key:
+            litellm.api_key = api_key
+            
+        # Conversation state
+        self.messages = [{
+            "role": "system",
+            "content": system_prompt or (
+                "You are a helpful AI assistant with access to a variety of tools. "
+                "Use the tools when appropriate to accomplish tasks. "
+                "If a tool you need isn't available, just say so."
+            )
+        }]
+        
+        # Available tools (will be populated after connecting to MCP servers)
+        self.available_tools = []
+        
+        # Control flow tools
+        self.exit_loop_tools = [
+            {
+                "type": "function",
+                "function": {
+                    "name": "task_complete",
+                    "description": "Call this tool when the task given by the user is complete",
+                    "parameters": {"type": "object", "properties": {}}
+                }
+            },
+            {
+                "type": "function",
+                "function": {
+                    "name": "ask_question",
+                    "description": "Ask a question to the user to get more info required to solve or clarify their problem.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "question": {
+                                "type": "string",
+                                "description": "The question to ask the user"
+                            }
+                        },
+                        "required": ["question"]
+                    }
+                }
+            }
+        ]
+    
+    async def connect_to_server(self, command: str, args: List[str]) -> None:
+        """
+        Connect to an MCP server and fetch available tools.
+        
+        Args:
+            command: The command to run the server
+            args: List of arguments for the server
+        """
+        await self.mcp_client.connect(command, args)
+        
+        # Get available tools from the server and format them for LiteLLM
+        resp = await self.mcp_client.session.list_tools()
+        
+        tool_descriptions = []
+        for tool in resp.tools:
+            tool_descriptions.append({
+                "type": "function",
+                "function": {
+                    "name": tool.name,
+                    "description": tool.description,
+                    "parameters": tool.inputSchema
+                }
+            })
+        
+        logger.info(f"Added {len(tool_descriptions)} tools from MCP server")
+        self.available_tools.extend(tool_descriptions)
+    
+    async def run(self, user_input: str, max_turns: int = 10) -> str:
+        """
+        Run the agent with user input.
+        
+        Args:
+            user_input: The user's request
+            max_turns: Maximum number of turns before giving up
+            
+        Returns:
+            The final agent response
+        """
+        # Add user message to conversation
+        self.messages.append({"role": "user", "content": user_input})
+        
+        # Initialize loop control variables
+        num_turns = 0
+        next_turn_should_call_tools = True
+        
+        # The main agent loop
+        while True:
+            # Get all available tools including exit loop tools
+            all_tools = self.available_tools + self.exit_loop_tools
+            
+            # Call LLM with messages and tools
+            try:
+                logger.info(f"Calling LLM with {len(self.messages)} messages and {len(all_tools)} tools")
+                response = await litellm.acompletion(
+                    model=self.model,
+                    messages=self.messages,
+                    tools=all_tools,
+                    tool_choice="auto"
+                )
+                
+                # Process the response - properly handle the object
+                response_message = response.choices[0].message
+                logger.debug(f"🔥🔥🔥🔥🔥🔥 Response : {response_message}")
+                
+                # Create a proper message dictionary from the response object's attributes
+                assistant_message = {
+                    "role": "assistant",
+                    "content": response_message.content if hasattr(response_message, "content") else ""
+                }
+                
+                # Check if the message has tool_calls attribute and it's not empty
+                has_tool_calls = hasattr(response_message, "tool_calls") and response_message.tool_calls
+                
+                if has_tool_calls:
+                    # Add tool_calls to the message if present
+                    assistant_message["tool_calls"] = response_message.tool_calls
+                
+                # Add the properly formatted assistant message to conversation
+                self.messages.append(assistant_message)
+                
+                # Process tool calls if they exist
+                if has_tool_calls:
+                    tool_calls = response_message.tool_calls
+                    logger.info(f"Tool calls detected: {len(tool_calls)}")
+                    
+                    # Process each tool call one by one
+                    for tool_call in tool_calls:
+                        tool_call_id = tool_call.id
+                        function_info = tool_call.function
+                        tool_name = function_info.name
+                        
+                        # Create a tool message
+                        tool_message = {
+                            "role": "tool",
+                            "tool_call_id": tool_call_id,
+                            "name": tool_name,
+                            "content": ""  # Default empty content
+                        }
+                        
+                        try:
+                            # Parse tool arguments
+                            try:
+                                tool_args = json.loads(function_info.arguments)
+                            except json.JSONDecodeError:
+                                logger.error(f"Could not parse tool arguments: {function_info.arguments}")
+                                tool_args = {}
+                            
+                            # Handle control flow tools
+                            if tool_name == "task_complete":
+                                # Add a response for this tool call before returning
+                                tool_message["content"] = "Task has been completed successfully."
+                                self.messages.append(tool_message)
+                                return "Task completed."
+                            elif tool_name == "ask_question":
+                                question = tool_args.get("question", "Could you provide more details?")
+                                # Add a response for this tool call before returning
+                                tool_message["content"] = f"Question asked: {question}"
+                                self.messages.append(tool_message)
+                                return f"I need more information: {question}"
+                            else:
+                                # Call the actual tool using MCPClient
+                                try:
+                                    content_list = await self.mcp_client.call_tool(tool_name, tool_args)
+                                    
+                                    # Safely extract text from the content
+                                    if content_list:
+                                        # Try different ways to extract the content
+                                        if hasattr(content_list[0], 'text'):
+                                            tool_message["content"] = content_list[0].text
+                                        elif isinstance(content_list[0], dict) and 'text' in content_list[0]:
+                                            tool_message["content"] = content_list[0]['text']
+                                        else:
+                                            tool_message["content"] = str(content_list)
+                                    else:
+                                        tool_message["content"] = "Tool returned no content"
+                                except Exception as e:
+                                    logger.error(f"Error calling tool {tool_name}: {str(e)}")
+                                    tool_message["content"] = f"Error executing tool {tool_name}: {str(e)}"
+                        except Exception as e:
+                            # If any error occurs during tool call processing, make sure we still have a tool response
+                            logger.error(f"Unexpected error processing tool call {tool_call_id}: {str(e)}")
+                            tool_message["content"] = f"Error processing tool call: {str(e)}"
+                        
+                        # Always add the tool message to ensure each tool call has a response
+                        self.messages.append(tool_message)
+                    
+                    next_turn_should_call_tools = False
+                else:
+                    # No tool calls in this message
+                    if next_turn_should_call_tools and num_turns > 0:
+                        # If we expected tool calls but didn't get any, we're done
+                        return assistant_message["content"] or ""
+                    
+                    next_turn_should_call_tools = True
+                
+                num_turns += 1
+                if num_turns >= max_turns:
+                    return "Max turns reached. Task incomplete."
+                
+            except Exception as e:
+                logger.error(f"Error in agent loop: {str(e)}")
+                return f"Error: {str(e)}"
+
+    
+    async def close(self):
+        """Clean up resources."""
+        await self.mcp_client.close()

tinyagent_py-0.0.1/tinyagent_py.egg-info/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: tinyagent-py
+Version: 0.0.1
+Summary: Tiny Agent with MCP Client
+Author-email: Mahdi Golchin <golchin@askdev.ai>
+License: MIT
+Project-URL: Homepage, https://github.com/askbudi/tinyagent
+Project-URL: Bug Tracker, https://github.com/askbudi/tinyagent/issues
+Project-URL: Chat, https://askdev.ai/github/askbudi/tinyagent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp
+Requires-Dist: litellm
+Requires-Dist: openai
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# tinyagent
+Tiny Agent: 100 lines Agent with MCP
+
+Inspired by:
+- [Tiny Agents blog post](https://huggingface.co/blog/tiny-agents)
+- [12-factor-agents repository](https://github.com/humanlayer/12-factor-agents)
+- Created by chatting to the source code of JS Tiny Agent using [AskDev.ai](https://askdev.ai/search)
+
+## Quick Links
+- [Build your own Tiny Agent](https://askdev.ai/github/askbudi/tinyagent)
+
+## Overview
+This is a tiny agent that uses MCP and LiteLLM to interact with a model. You have full control over the agent, you can add any tools you like from MCP and extend the agent using its event system.
+
+## Installation
+
+### Using pip
+```bash
+pip install tinyagent
+```
+
+### Using uv
+```bash
+uv pip install tinyagent
+```
+
+## Usage
+
+```python
+from tinyagent import TinyAgent
+from textwrap import dedent
+import asyncio
+import os
+
+async def test_agent(task, model="o4-mini", api_key=None):
+    # Initialize the agent with model and API key
+    agent = TinyAgent(
+        model=model,  # Or any model supported by LiteLLM
+        api_key=os.environ.get("OPENAI_API_KEY") if not api_key else api_key  # Set your API key as an env variable
+    )
+    
+    try:
+        # Connect to an MCP server
+        # Replace with your actual server command and args
+        await agent.connect_to_server("npx", ["@openbnb/mcp-server-airbnb", "--ignore-robots-txt"])
+        
+        # Run the agent with a user query
+        result = await agent.run(task)
+        print("\nFinal result:", result)
+        return result
+    finally:
+        # Clean up resources
+        await agent.close()
+
+# Example usage
+task = dedent("""
+I need accommodation in Toronto between 15th to 20th of May. Give me 5 options for 2 adults.
+""")
+await test_agent(task, model="gpt-4.1-mini")
+```

tinyagent_py-0.0.1/tinyagent_py.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+tinyagent/__init__.py
+tinyagent/mcp_client.py
+tinyagent/tiny_agent.py
+tinyagent_py.egg-info/PKG-INFO
+tinyagent_py.egg-info/SOURCES.txt
+tinyagent_py.egg-info/dependency_links.txt
+tinyagent_py.egg-info/requires.txt
+tinyagent_py.egg-info/top_level.txt

tinyagent_py-0.0.1/tinyagent_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tinyagent_py-0.0.1/tinyagent_py.egg-info/requires.txt

@@ -0,0 +1,6 @@
+mcp
+litellm
+openai
+
+[dev]
+pytest

tinyagent_py-0.0.1/tinyagent_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+tinyagent