unimcp 0.1.0__tar.gz

unimcp-0.1.0/.gitignore

@@ -0,0 +1,41 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDEs
+.vscode/
+.idea/
+
+# Testing
+.pytest_cache/
+htmlcov/
+.coverage

unimcp-0.1.0/PKG-INFO

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: unimcp
+Version: 0.1.0
+Summary: A simple client library to connect to any MCP server and interact with LLMs.
+Project-URL: Homepage, https://github.com/barada02/UniMCP
+Project-URL: Bug Tracker, https://github.com/barada02/UniMCP/issues
+Author-email: Chandan Kumar Barad <chandanbarada2@gmail.com>
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: mcp==1.27.0
+Requires-Dist: openai==2.33.0
+Requires-Dist: python-dotenv
+Description-Content-Type: text/markdown
+
+# UniMCP
+
+A simple client library to connect to any MCP server and interact with tools seamlessly via code or through an LLM.
+
+## Installation
+
+```bash
+pip install unimcp
+```
+
+*(Note: While in development, you can install it locally using `pip install -e .`)*
+
+## Features
+- **Simple MCP Client**: Connect to any MCP server, list available tools, and call them directly with just a few lines of Python.
+- **LLM Integration**: Built-in wrapper to hook your MCP server tools directly into OpenAI (or any OpenAI-compatible API), enabling an LLM agent out-of-the-box.
+
+## Usage
+
+### 1. Using only the MCP Client (No LLM)
+
+```python
+import asyncio
+from unimcp import UniClient
+
+async def main():
+    # Connect to your MCP server
+    async with UniClient("http://localhost:8000/sse") as client:
+        # 1. Get available tools
+        tools = await client.get_tools()
+        print("Available tools:", [t.name for t in tools])
+
+        # 2. Call a specific tool manually
+        result = await client.call_tool("my_tool_name", {"arg1": "value"})
+        print("Tool Result:", result)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### 2. Using the LLM Client
+
+This utilizes OpenAI's python library under the hood. You can configure it using environment variables (`OPENAI_API_KEY`, `OPENAI_BASE_URL`, `OPENAI_MODEL`) or pass them directly.
+
+```python
+import asyncio
+from unimcp import UniClient, UniLLM
+
+async def main():
+    async with UniClient("http://localhost:8000/sse") as client:
+        
+        # Initialize the LLM with the MCP client
+        # It automatically detects OPENAI_API_KEY from environment variables
+        llm = UniLLM(client, model_name="gpt-4o")
+        
+        # Optionally set a system prompt
+        llm.set_system_prompt("You are a helpful assistant with access to MCP tools.")
+
+        # Chat with the LLM (it will automatically use the tools if needed)
+        response = await llm.chat("Can you perform an action using your tools?")
+        print("AI:", response)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Environment Variables
+The `UniLLM` automatically respects the following standard environment variables:
+- `OPENAI_API_KEY`: Your API key.
+- `OPENAI_BASE_URL`: For connecting to local LLMs (like LMStudio, Ollama) or other providers.
+- `OPENAI_MODEL`: Default model to use (fallback is `gpt-4o`).

unimcp-0.1.0/README.md

@@ -0,0 +1,70 @@
+# UniMCP
+
+A simple client library to connect to any MCP server and interact with tools seamlessly via code or through an LLM.
+
+## Installation
+
+```bash
+pip install unimcp
+```
+
+*(Note: While in development, you can install it locally using `pip install -e .`)*
+
+## Features
+- **Simple MCP Client**: Connect to any MCP server, list available tools, and call them directly with just a few lines of Python.
+- **LLM Integration**: Built-in wrapper to hook your MCP server tools directly into OpenAI (or any OpenAI-compatible API), enabling an LLM agent out-of-the-box.
+
+## Usage
+
+### 1. Using only the MCP Client (No LLM)
+
+```python
+import asyncio
+from unimcp import UniClient
+
+async def main():
+    # Connect to your MCP server
+    async with UniClient("http://localhost:8000/sse") as client:
+        # 1. Get available tools
+        tools = await client.get_tools()
+        print("Available tools:", [t.name for t in tools])
+
+        # 2. Call a specific tool manually
+        result = await client.call_tool("my_tool_name", {"arg1": "value"})
+        print("Tool Result:", result)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+### 2. Using the LLM Client
+
+This utilizes OpenAI's python library under the hood. You can configure it using environment variables (`OPENAI_API_KEY`, `OPENAI_BASE_URL`, `OPENAI_MODEL`) or pass them directly.
+
+```python
+import asyncio
+from unimcp import UniClient, UniLLM
+
+async def main():
+    async with UniClient("http://localhost:8000/sse") as client:
+        
+        # Initialize the LLM with the MCP client
+        # It automatically detects OPENAI_API_KEY from environment variables
+        llm = UniLLM(client, model_name="gpt-4o")
+        
+        # Optionally set a system prompt
+        llm.set_system_prompt("You are a helpful assistant with access to MCP tools.")
+
+        # Chat with the LLM (it will automatically use the tools if needed)
+        response = await llm.chat("Can you perform an action using your tools?")
+        print("AI:", response)
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Environment Variables
+The `UniLLM` automatically respects the following standard environment variables:
+- `OPENAI_API_KEY`: Your API key.
+- `OPENAI_BASE_URL`: For connecting to local LLMs (like LMStudio, Ollama) or other providers.
+- `OPENAI_MODEL`: Default model to use (fallback is `gpt-4o`).

unimcp-0.1.0/error.log

@@ -0,0 +1,32 @@
+(venv) (base) PS C:\Users\barad\Desktop\projects\UniMCP> python sc.py
+Traceback (most recent call last):
+  File "C:\Users\barad\Desktop\projects\UniMCP\sc.py", line 19, in <module>
+    asyncio.run(main())
+    ~~~~~~~~~~~^^^^^^^^
+  File "C:\Users\barad\anaconda3\Lib\asyncio\runners.py", line 195, in run
+    return runner.run(main)
+           ~~~~~~~~~~^^^^^^
+  File "C:\Users\barad\anaconda3\Lib\asyncio\runners.py", line 118, in run
+    return self._loop.run_until_complete(task)
+           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^
+  File "C:\Users\barad\anaconda3\Lib\asyncio\base_events.py", line 725, in run_until_complete
+    return future.result()
+           ~~~~~~~~~~~~~^^
+  File "C:\Users\barad\Desktop\projects\UniMCP\sc.py", line 16, in main
+    response = await llm.chat("hi can you save my friends name dinesh and his phone number is 9009876543 and his email id is dinesh@gmail.com ")        
+               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^        
+  File "C:\Users\barad\Desktop\projects\UniMCP\src\unimcp\llm.py", line 73, in chat
+    response = await self.client.chat.completions.create(**chat_kwargs)     
+               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^     
+  File "C:\Users\barad\Desktop\projects\UniMCP\venv\Lib\site-packages\openai\resources\chat\completions\completions.py", line 2714, in create
+    return await self._post(
+           ^^^^^^^^^^^^^^^^^
+    ...<49 lines>...
+    )
+    ^
+  File "C:\Users\barad\Desktop\projects\UniMCP\venv\Lib\site-packages\openai\_base_client.py", line 1913, in post
+    return await self.request(cast_to, opts, stream=stream, stream_cls=stream_cls)
+           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  File "C:\Users\barad\Desktop\projects\UniMCP\venv\Lib\site-packages\openai\_base_client.py", line 1698, in request
+    raise self._make_status_error_from_response(err.response) from None     
+openai.NotFoundError: Error code: 404 - [{'error': {'code': 404, 'message': 'models/gpt-4o is not found for API version v1main, or is not supported for generateContent. Call ListModels to see the list of available models and their supported methods.', 'status': 'NOT_FOUND'}}]

unimcp-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "unimcp"
+version = "0.1.0"
+description = "A simple client library to connect to any MCP server and interact with LLMs."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [
+  { name = "Chandan Kumar Barad", email = "chandanbarada2@gmail.com" },
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "mcp==1.27.0",
+    "openai==2.33.0",
+    "python-dotenv"
+]
+
+[project.urls]
+"Homepage" = "https://github.com/barada02/UniMCP"
+"Bug Tracker" = "https://github.com/barada02/UniMCP/issues"

unimcp-0.1.0/reference/client.py

@@ -0,0 +1,138 @@
+import asyncio
+import os
+import json
+from dotenv import load_dotenv
+from openai import AsyncOpenAI
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+
+# Load environment variables
+load_dotenv()
+
+# Initialize OpenAI Client
+# Base URL and API Key are automatically pulled from OPENAI_BASE_URL and OPENAI_API_KEY env variables
+openai_client = AsyncOpenAI()
+MODEL_NAME = os.getenv("OPENAI_MODEL", "gpt-4o")
+
+def convert_mcp_to_openai_tools(mcp_tools) -> list:
+    """
+    Helper function to convert MCP tool definitions into the format 
+    that the OpenAI API expects.
+    """
+    openai_tools = []
+    for tool in mcp_tools:
+        openai_tools.append({
+            "type": "function",
+            "function": {
+                "name": tool.name,
+                "description": tool.description,
+                # MCP uses JSON Schema for inputs, which matches OpenAI closely
+                "parameters": tool.inputSchema
+            }
+        })
+    return openai_tools
+
+async def chat_interaction_loop(session: ClientSession):
+    """
+    Continuous chat loop that keeps conversation history.
+    """
+    print("\n[Client] Initializing session history...")
+    
+    # Ask the MCP server what tools it has available
+    tools_response = await session.list_tools()
+    available_openai_tools = convert_mcp_to_openai_tools(tools_response.tools)
+    print(f"[Client] Server provides {len(available_openai_tools)} tools.")
+    print(f"[Client] Tools: {[tool['function']['name'] for tool in available_openai_tools]}")
+    #print(f"[Client] tools: {json.dumps(available_openai_tools, indent=2)}")
+
+    # System prompt gives the AI a personality and rules
+    system_prompt = (
+        "You are a helpful assistant hooked up to an external database. "
+        "You MUST use your provided tools to save user preferences, personal details, and contacts. "
+        f"You have [{len(available_openai_tools)}] tools available to interact with the file system. "
+        "Whenever the user mentions a fact about themselves or a friend, immediately call the appropriate tool."
+    )
+    
+    messages = [
+        {
+            "role": "system", 
+            "content": system_prompt
+        }
+    ]
+    
+    print("\n--- Chat Started! Type 'exit' or 'quit' to stop. ---")
+    
+    while True:
+        # Prompt user for input
+        user_prompt = input("\nYou: ")
+        if user_prompt.lower() in ("exit", "quit"):
+            print("Goodbye!")
+            break
+            
+        messages.append({"role": "user", "content": user_prompt})
+
+        # We use a loop here because sometimes the AI calls a tool, gets the result,
+        # but decides it needs to call ANOTHER tool before answering the user.
+        while True:
+            try:
+                response = await openai_client.chat.completions.create(
+                    model=MODEL_NAME,
+                    messages=messages,
+                    tools=available_openai_tools,
+                    tool_choice="auto" # Wait, some models need this explicitly set
+                )
+            except Exception as e:
+                print(f"\n[Error] The LLM Provider returned an error: {e}")
+                print("[Hint] If you hit a rate limit, try waiting a minute, or change the model in your .env file.")
+                break
+                
+            response_message = response.choices[0].message
+            # We MUST append the assistant's message to the conversation history
+            # either as a text response or a tool call response
+            messages.append(response_message)
+        
+            # If the LLM decides to call a tool (or multiple tools)
+            if response_message.tool_calls:
+                for tool_call in response_message.tool_calls:
+                    tool_name = tool_call.function.name
+                    tool_args = json.loads(tool_call.function.arguments)
+                    
+                    print(f"\n[Processing] Calling tool '{tool_name}' with args: {tool_args}")
+                    
+                    # Call the tool on the MCP server
+                    result = await session.call_tool(tool_name, arguments=tool_args)
+                    
+                    # Read the response text from the server
+                    tool_result_str = ""
+                    for content in result.content:
+                        if content.type == "text":
+                            tool_result_str += content.text
+                            
+                    print(f"[Processing] Server replied: {tool_result_str.strip()}")
+                    
+                    # Feed the result back to the LLM
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "name": tool_name,
+                        "content": tool_result_str
+                    })
+                # After feeding all tool results, let the `while True` loop run again
+                # so the LLM can generate its final response (or call another tool!)
+            else:
+                # No more tools requested, the LLM has given us text response
+                print(f"AI: {response_message.content}")
+                break # Break inner loop, go back to waiting for User input
+
+async def main():
+    print("Connecting to remote MCP server via SSE...")
+    async with sse_client(url="http://localhost:8000/sse") as (read_stream, write_stream):
+        async with ClientSession(read_stream, write_stream) as session:
+            await session.initialize()
+            print("Connected and initialized successfully!")
+
+            # Start interactive chat
+            await chat_interaction_loop(session)
+
+if __name__ == "__main__":
+    asyncio.run(main())

unimcp-0.1.0/reference/client_architecture.md

@@ -0,0 +1,90 @@
+# MCP Client Architecture & Dataflow
+
+This document explains exactly how our custom MCP Client (`client.py`) operates. 
+
+A common misconception is that the "AI executes tools." **This is false.** An LLM is entirely isolated; it is merely a text predicting engine. It cannot access your file system or the internet on its own. 
+
+The **Client** is the true powerhouse. It acts as the Orchestrator that sits in the middle of three entities:
+1. **The User** (Providing prompts)
+2. **The LLM** (Making decisions and formatting text)
+3. **The MCP Server** (Performing actual programmatic actions)
+
+---
+
+## 1. High-Level Dataflow
+
+```mermaid
+graph TD
+    User((User)) <-->|Text Prompts / Text Answers| Client[MCP Client orchestrator]
+    Client <-->|SSE / JSON-RPC\nExecutes Tools| Server[(MCP Server)]
+    Client <-->|REST API\nSends Prompts & Gets JSON| LLM{LLM API}
+    Server <-->|File I/O| FS[(Local File System / OS)]
+```
+
+---
+
+## 2. Step-by-Step Breakdown of the Workflow
+
+### Phase 1: Initialization & Tool Discovery
+Before the user even types a message, the Client needs to figure out what the MCP Server can do.
+
+1. **Connect:** The Client establishes an SSE (Server-Sent Events) connection to `http://localhost:8000/sse`.
+2. **List Tools:** The Client asks the MCP Server, *"What tools do you have?"*
+3. **Schema Conversion:** MCP SDK returns tool definitions in standard JSON-Schema format. The Client converts these into the strict `{"type": "function", ...}` schema format required by the OpenAI/LLM API.
+
+### Phase 2: The Chat & Execution Loop
+This is the core of the client design. It utilizes a continuous **loop-within-a-loop** architecture.
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant U as User
+    participant C as Client (Python)
+    participant L as LLM (OpenAI API)
+    participant S as MCP Server (FastMCP)
+
+    U->>C: "Save my name as John"
+    
+    rect rgba(128, 128, 128, 0.2)
+        Note over C, L: The Execution Loop
+        C->>L: Send [History] + [Available Tools]
+        L-->>C: Response: Tool Call Requested! <br/> {"name": "save_user_detail", "args": {"key": "name", "value": "John"}}
+        
+        Note over C, S: The Client physically executes the tool
+        C->>S: JSON-RPC: Call Tool `save_user_detail`
+        S-->>C: Result: "Successfully saved"
+        
+        Note over C, L: Client feeds result back to LLM context
+        C->>L: Send [History] + [Tool Result: "Successfully saved"]
+        L-->>C: Response: Pure Text <br/> "I have saved your name as John!"
+    end
+    
+    C->>U: "I have saved your name as John!"
+```
+
+---
+
+## 3. Why the Infinite Inner Loop? (`while True:`)
+
+In `client.py`, you will notice an inner `while True:` loop wrapped around the LLM API call. Why do we need this?
+
+**Because an LLM might need to chain multiple tools together to fulfill a single prompt.**
+
+Imagine the user asks: *"What is my name, and what is my system OS?"*
+
+1. **Iteration 1:** The LLM receives the prompt. It outputs a JSON token requesting to call `get_all_data`. 
+2. The Client parses this, calls the server, and gets the JSON string back. The Client appends this to the message history.
+3. **Iteration 2 (Inside the loop):** The Client immediately sends the updated history back to the LLM. The LLM reads the history, sees it now has the user's name, but realizes it *still* needs the OS. It outputs another JSON token requesting to call `get_system_status`.
+4. The Client parses this, calls the server, gets the OS, and appends it to the history.
+5. **Iteration 3 (Inside the loop):** The Client sends the history to the LLM *again*. This time, the LLM has all the pieces. It generates the final conversational text. 
+6. The Client detects this is text (not a tool call payload), **breaks the inner loop**, and prints the final answer to the user.
+
+## Summary
+
+The LLM is just a brain that looks at the available functions and outputs JSON payloads saying *"I think you should run this function with these arguments"*. 
+
+**The MCP Client:**
+1. Parses those JSON requests.
+2. Actually makes the network/local calls to execute the functions on the MCP Server.
+3. Captures the physical output of the system.
+4. Feeds that output back to the LLM so it knows what happened.

unimcp-0.1.0/reference/server.py

@@ -0,0 +1,78 @@
+from mcp.server.fastmcp import FastMCP
+import platform
+import datetime
+import json
+import os
+
+# Create server with a specific name
+mcp = FastMCP("remote-system-notes")
+
+DB_FILE = "user_data.json"
+
+def _load_data() -> dict:
+    if not os.path.exists(DB_FILE):
+        return {}
+    with open(DB_FILE, "r") as f:
+        return json.load(f)
+
+def _save_data(data: dict):
+    with open(DB_FILE, "w") as f:
+        json.dump(data, f, indent=4)
+
+@mcp.tool()
+def get_system_status() -> str:
+    """
+    Get the current system status, including OS details and current time.
+    """
+    os_info = platform.system() + " " + platform.release()
+    current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    return f"System: {os_info}\nCurrent Time: {current_time}\nStatus: All systems operational."
+
+@mcp.tool()
+def get_all_data() -> str:
+    """Read and retrieve all saved user data and contacts from the database."""
+    data = _load_data()
+    if not data:
+        return "The database is currently empty."
+    return json.dumps(data, indent=2)
+
+@mcp.tool()
+def save_user_detail(key: str, value: str) -> str:
+    """
+    Save or update a piece of personal information about the user (e.g., 'name', 'age', 'email').
+    """
+    data = _load_data()
+    if "user" not in data:
+        data["user"] = {}
+    data["user"][key] = value
+    _save_data(data)
+    return f"Successfully saved user detail: {key} = {value}"
+
+@mcp.tool()
+def save_contact(name: str, phone: str = "", email: str = "") -> str:
+    """
+    Save or update a contact/friend's details.
+    Must provide the name, and optionally a phone number or email string.
+    """
+    data = _load_data()
+    if "contacts" not in data:
+        data["contacts"] = {}
+    data["contacts"][name] = {"phone": phone, "email": email}
+    _save_data(data)
+    return f"Contact '{name}' saved successfully."
+
+if __name__ == "__main__":
+    # FastMCP supports 'sse' (Server-Sent Events) for acting as a remote HTTP server
+    # Note: running this requires 'uvicorn' and 'starlette' (pip install uvicorn starlette)
+    import sys
+    print("Starting Remote MCP Server on http://localhost:8000/sse")
+    print("Press CTRL+C to close.")
+    
+    try:
+        mcp.run(transport="sse")
+    except KeyboardInterrupt:
+        print("\nShutting down server gracefully...")
+        sys.exit(0)
+    except Exception as e:
+        print(f"\nServer stopped unexpectedly: {e}")
+        sys.exit(1)

unimcp-0.1.0/sc.py

@@ -0,0 +1,19 @@
+import asyncio
+from unimcp import UniClient, UniLLM
+import os
+import dotenv
+dotenv.load_dotenv()
+
+url=os.getenv("OPENAI_BASE_URL")
+token=os.getenv("OPENAI_API_KEY")
+model_name=os.getenv("OPENAI_MODEL")
+
+async def main():
+    async with UniClient("http://localhost:8000/sse") as client:
+        # Pass in base_url, api_key, model_name OR let it read from .env!
+        llm = UniLLM(client, model_name=model_name,api_key=token,base_url=url)
+        
+        response = await llm.chat("hi can you save my friends name dinesh and his phone number is 9009876543 and his email id is dinesh@gmail.com ")
+        print("AI:", response)
+
+asyncio.run(main())

unimcp-0.1.0/src/unimcp/__init__.py

@@ -0,0 +1,9 @@
+"""
+UniMCP package - Connect to MCP servers and use them pythonically or with LLMs.
+"""
+
+from .client import UniClient
+from .llm import UniLLM
+
+__version__ = "0.1.0"
+__all__ = ["UniClient", "UniLLM"]

unimcp-0.1.0/src/unimcp/client.py

@@ -0,0 +1,57 @@
+import asyncio
+from typing import Optional, List, Dict, Any
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+from contextlib import AsyncExitStack
+
+class UniClient:
+    """
+    A unified MCP Client that connects to an MCP server (SSE by default)
+    and allows execution of tools.
+    """
+    def __init__(self, url: str):
+        self.url = url
+        self.session: Optional[ClientSession] = None
+        self._exit_stack: Optional[AsyncExitStack] = None
+
+    async def connect(self):
+        """Connects to the MCP server."""
+        self._exit_stack = AsyncExitStack()
+        read_stream, write_stream = await self._exit_stack.enter_async_context(sse_client(url=self.url))
+        self.session = await self._exit_stack.enter_async_context(ClientSession(read_stream, write_stream))
+        await self.session.initialize()
+
+    async def disconnect(self):
+        """Disconnects from the MCP server."""
+        if self._exit_stack:
+            await self._exit_stack.aclose()
+            self._exit_stack = None
+            self.session = None
+
+    async def __aenter__(self):
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.disconnect()
+
+    async def get_tools(self) -> List[Any]:
+        """Lists available tools from the MCP server."""
+        if not self.session:
+            raise RuntimeError("Client not connected. Call connect() first.")
+        response = await self.session.list_tools()
+        return response.tools
+
+    async def call_tool(self, tool_name: str, arguments: Dict[str, Any]) -> str:
+        """Executes a tool on the MCP server and returns the text result."""
+        if not self.session:
+            raise RuntimeError("Client not connected. Call connect() first.")
+        
+        result = await self.session.call_tool(tool_name, arguments=arguments)
+        
+        # Read the response text from the server
+        tool_result_str = ""
+        for content in result.content:
+            if content.type == "text":
+                tool_result_str += content.text
+        return tool_result_str

unimcp-0.1.0/src/unimcp/llm.py

@@ -0,0 +1,97 @@
+from typing import Optional, List, Dict, Any
+from openai import AsyncOpenAI
+import json
+import os
+
+class UniLLM:
+    """
+    A unified LLM wrapper that connects to OpenAI (or any OpenAI-compatible API)
+    and automatically executes tools provided by a UniClient.
+    """
+    def __init__(
+        self,
+        mcp_client,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        model_name: Optional[str] = None
+    ):
+        self.mcp_client = mcp_client
+        self.messages: List[Dict[str, Any]] = []
+        
+        kwargs = {}
+        # Priority: arguments > environment variables
+        final_api_key = api_key or os.getenv("OPENAI_API_KEY")
+        if final_api_key:
+            kwargs["api_key"] = final_api_key
+            
+        final_base_url = base_url or os.getenv("OPENAI_BASE_URL")
+        if final_base_url:
+            kwargs["base_url"] = final_base_url
+            
+        self.model_name = model_name or os.getenv("OPENAI_MODEL", "gpt-4o")
+        self.client = AsyncOpenAI(**kwargs)
+
+    def _convert_mcp_to_openai_tools(self, mcp_tools) -> list:
+        openai_tools = []
+        for tool in mcp_tools:
+            openai_tools.append({
+                "type": "function",
+                "function": {
+                    "name": tool.name,
+                    "description": tool.description,
+                    "parameters": tool.inputSchema
+                }
+            })
+        return openai_tools
+
+    def set_system_prompt(self, prompt: str):
+        """Sets the system prompt for the LLM."""
+        if self.messages and self.messages[0]["role"] == "system":
+            self.messages[0]["content"] = prompt
+        else:
+            self.messages.insert(0, {"role": "system", "content": prompt})
+
+    async def chat(self, user_input: str) -> str:
+        """
+        Sends a user message to the LLM and processes any required tool calls 
+        from the MCP server before returning the final text response.
+        """
+        self.messages.append({"role": "user", "content": user_input})
+        
+        mcp_tools = await self.mcp_client.get_tools()
+        available_openai_tools = self._convert_mcp_to_openai_tools(mcp_tools)
+        
+        while True:
+            chat_kwargs = {
+                "model": self.model_name,
+                "messages": self.messages,
+            }
+            if available_openai_tools:
+                chat_kwargs["tools"] = available_openai_tools
+                chat_kwargs["tool_choice"] = "auto"
+                
+            response = await self.client.chat.completions.create(**chat_kwargs)
+            response_message = response.choices[0].message
+            
+            # Append the assistant's message to the history
+            self.messages.append(response_message)
+            
+            # If the LLM decides to call a tool (or multiple tools)
+            if response_message.tool_calls:
+                for tool_call in response_message.tool_calls:
+                    tool_name = tool_call.function.name
+                    tool_args = json.loads(tool_call.function.arguments)
+                    
+                    # Execute tool via MCP client
+                    tool_result_str = await self.mcp_client.call_tool(tool_name, tool_args)
+                    
+                    # Feed the result back to the LLM
+                    self.messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "name": tool_name,
+                        "content": tool_result_str
+                    })
+                # After resolving tools, loop to let the LLM generate a final text response
+            else:
+                return response_message.content

unimcp-0.1.0/tests/__init__.py

@@ -0,0 +1 @@
+# Empty tests init

unimcp-0.1.0/user_data.json

@@ -0,0 +1,8 @@
+{
+    "contacts": {
+        "dinesh": {
+            "phone": "9009876543",
+            "email": "dinesh@gmail.com"
+        }
+    }
+}