universal-mcp 0.1.23rc2__py3-none-any.whl → 0.1.24rc2__py3-none-any.whl

universal_mcp/utils/singleton.py

@@ -1,3 +1,6 @@
+from typing import Any
+
+
 class Singleton(type):
     """Metaclass that ensures only one instance of a class exists.
 
@@ -15,7 +18,7 @@ class Singleton(type):
         assert a is b  # True
     """
 
-    _instances = {}
+    _instances: dict[type, Any] = {}
 
     def __call__(cls, *args, **kwargs):
         if cls not in cls._instances:

universal_mcp/utils/testing.py

@@ -5,9 +5,9 @@ from universal_mcp.tools.tools import Tool
 
 def check_application_instance(app_instance, app_name):
     assert app_instance is not None, f"Application object is None for {app_name}"
-    assert (
-        app_instance.name == app_name
-    ), f"Application instance name '{app_instance.name}' does not match expected name '{app_name}'"
+    assert app_instance.name == app_name, (
+        f"Application instance name '{app_instance.name}' does not match expected name '{app_name}'"
+    )
 
     tools = app_instance.list_tools()
     logger.info(f"Tools for {app_name}: {len(tools)}")
@@ -19,9 +19,9 @@ def check_application_instance(app_instance, app_name):
 
     for tool in tools:
         assert tool.name is not None, f"Tool name is None for a tool in {app_name}"
-        assert (
-            0 < len(tool.name) <= 48
-        ), f"Tool name '{tool.name}' for {app_name} has invalid length (must be between 1 and 47 characters)"
+        assert 0 < len(tool.name) <= 48, (
+            f"Tool name '{tool.name}' for {app_name} has invalid length (must be between 1 and 47 characters)"
+        )
         assert tool.description is not None, f"Tool description is None for tool '{tool.name}' in {app_name}"
         # assert 0 < len(tool.description) <= 255, f"Tool description for '{tool.name}' in {app_name} has invalid length (must be between 1 and 255 characters)"
         assert tool.name not in seen_names, f"Duplicate tool name: '{tool.name}' found for {app_name}"

universal_mcp-0.1.24rc2.dist-info/METADATA

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: universal-mcp
+Version: 0.1.24rc2
+Summary: Universal MCP acts as a middle ware for your API applications. It can store your credentials, authorize, enable disable apps on the fly and much more.
+Author-email: Manoj Bajaj <manojbajaj95@gmail.com>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: black>=25.1.0
+Requires-Dist: cookiecutter>=2.6.0
+Requires-Dist: gql[all]>=3.5.2
+Requires-Dist: jinja2>=3.1.3
+Requires-Dist: jsonref>=1.1.0
+Requires-Dist: keyring>=25.6.0
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: mcp>=1.9.3
+Requires-Dist: posthog>=3.24.0
+Requires-Dist: pydantic-settings>=2.8.1
+Requires-Dist: pydantic>=2.11.1
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: rich>=14.0.0
+Requires-Dist: typer>=0.15.2
+Provides-Extra: dev
+Requires-Dist: litellm>=1.30.7; extra == 'dev'
+Requires-Dist: mypy>=1.16.0; extra == 'dev'
+Requires-Dist: pre-commit>=4.2.0; extra == 'dev'
+Requires-Dist: pyright>=1.1.398; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.26.0; extra == 'dev'
+Requires-Dist: pytest>=8.3.5; extra == 'dev'
+Requires-Dist: ruff>=0.11.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Universal MCP
+
+Universal MCP acts as a middleware layer for your API applications, enabling seamless integration with various services through the Model Control Protocol (MCP). It simplifies credential management, authorization, dynamic app enablement, and provides a robust framework for building and managing AI-powered tools.
+
+## Documentation
+
+The primary documentation for Universal MCP is available in `/docs` folder in this repository.
+
+Please refer to the following for more detailed information:
+
+*   **[Main Documentation](docs/index.md)**: For an overview of the project, features, quick start, and installation.
+*   **[Playground Usage](docs/playground.md)**: For instructions on using the interactive playground.
+*   **[Applications Framework](docs/applications.md)**: For details on the applications module.
+*   **[Integrations & Authentication](docs/integrations.md)**: For information on integration types.
+*   **[Server Implementations](docs/servers.md)**: For details on server types.
+*   **[Credential Stores](docs/stores.md)**: For information on credential stores.
+*   **[Tools Framework](docs/tools_framework.md)**: For details on the tool management system.
+*   **[Contributing Guidelines](CONTRIBUTING.md)**: For information on how to contribute to the project.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

universal_mcp-0.1.24rc2.dist-info/RECORD

@@ -0,0 +1,53 @@
+universal_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/analytics.py,sha256=8AjqAnqacos-1R9D6gf_eMbKFlBBIFSM9yv12AAnxlE,3961
+universal_mcp/cli.py,sha256=aVTUGImHpEklW0OpLBLCYyvjv3M2Prf1ntkwmlG-Jxg,2238
+universal_mcp/config.py,sha256=3CGLbwyhr4zq1kQ7vHIO4f6PyfmANFa9RVZEMVgSJ8U,10651
+universal_mcp/exceptions.py,sha256=bf45HkNY-RVYzv8l_nPaxS5P2UCFww_oZmq508TMKgY,2070
+universal_mcp/logger.py,sha256=VmH_83efpErLEDTJqz55Dp0dioTXfGvMBLZUx5smOLc,2116
+universal_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/applications/__init__.py,sha256=l19_sMs5766VFWU_7O2niamvvvfQOteysqylbqvjjGQ,3500
+universal_mcp/applications/application.py,sha256=di4vuvAiOgVophzlvLiyVILdR8hPuSLS46YLQDEVq-c,23823
+universal_mcp/applications/sample_tool_app.py,sha256=YfZGE6F-cqqJGLU3TxOk4fYlAuf-kCOdBw03S-5VcpE,2760
+universal_mcp/client/cli.py,sha256=dZ_Uwp9grRN2UWOuE2PQ9eUAyGelNGI4GQkkliD_6Vs,6242
+universal_mcp/client/oauth.py,sha256=O00zOUfQxINaruFU2zt-64DIR1_mAqrY8ykLQo-teJU,8679
+universal_mcp/client/token_store.py,sha256=6VAzjzJG49wYvmEDqksFvb-fVqdjHIKWv7yYyh_AuF8,3912
+universal_mcp/client/transport.py,sha256=xgAKBJ1-yCcTtl9cxzJgRn6to5Y9EvCwLc_WpDck3Dg,11838
+universal_mcp/client/agents/__init__.py,sha256=ZeoMWi6C6ZaP28EzPhjTFlreZUP-FGo__VPgnKnU4uw,121
+universal_mcp/client/agents/base.py,sha256=i8oAILtVoW4kHAx95fd8IaioqYrD1aqoWSRjUl05TaY,953
+universal_mcp/client/agents/llm.py,sha256=O1cVPlXPhXb-x7GFIZ4dYFdB_Wd1eWHTTEV9FoBl_OE,5062
+universal_mcp/client/agents/react.py,sha256=lI654OT-3gXwrTjbt0DTbB-tuim4ahqZ7vAFta_A6NY,2719
+universal_mcp/integrations/__init__.py,sha256=UHno85kYa9nCjep31WpJlLu6ObNQxHzp4T57Q5eNILE,770
+universal_mcp/integrations/integration.py,sha256=E-pC_VioPoJwyw5d_RquE7k2ygvXrAnphNzNt4NrOS0,19823
+universal_mcp/servers/__init__.py,sha256=BbtZxl69EQcs9PpxBCkwa-vJKcfESgBfXQ5UYlkRQTo,542
+universal_mcp/servers/server.py,sha256=CNLlVxNosqBipk1_WD0zQJz-MZDiK5k7d_tZMH3NpAQ,7542
+universal_mcp/stores/__init__.py,sha256=quvuwhZnpiSLuojf0NfmBx2xpaCulv3fbKtKaSCEmuM,603
+universal_mcp/stores/store.py,sha256=yWbEGZb53z3fpVyqGWbes63z1CtIzC_IuM49OXy__UY,10137
+universal_mcp/tools/__init__.py,sha256=Fatza_R0qYWmNF1WQSfUZZKQFu5qf-16JhZzdmyx3KY,333
+universal_mcp/tools/adapters.py,sha256=rnicV_WBgNe0WqVG60ms0o92BoRTRqd_C9jMMndx47c,3461
+universal_mcp/tools/docstring_parser.py,sha256=efEOE-ME7G5Jbbzpn7pN2xNuyu2M5zfZ1Tqu1lRB0Gk,8392
+universal_mcp/tools/func_metadata.py,sha256=F4jd--hoZWKPBbZihVtluYKUsIdXdq4a0VWRgMl5k-Q,10838
+universal_mcp/tools/manager.py,sha256=Zpwr95rj4CvCRMkdX3_q3kZ9fYm8SkuLa-UkURG3WZQ,11740
+universal_mcp/tools/tools.py,sha256=pHehD4dqaTSnMBNhsj0Gpb4_L8OIy1rlZOITIDt7cnU,3730
+universal_mcp/utils/__init__.py,sha256=8wi4PGWu-SrFjNJ8U7fr2iFJ1ktqlDmSKj1xYd7KSDc,41
+universal_mcp/utils/agentr.py,sha256=8G9ZGQEA_Od2O9C6p439UclbzBgjvWB09Xej71NoAVk,3727
+universal_mcp/utils/common.py,sha256=HEZC2Mhilb8DrGXQG2tboAIw1r4veGilGWjfnPF1lyA,888
+universal_mcp/utils/installation.py,sha256=PU_GfHPqzkumKk-xG4L9CkBzSmABxmchwblZkx-zY-I,7204
+universal_mcp/utils/prompts.py,sha256=g6esB47Z5BNZxubQtZ21faJUcpH8-wRfS4xgk-2vECs,33284
+universal_mcp/utils/singleton.py,sha256=RoOiKxBOAhp0TK1QaMDYi-8GjRcy2Vh-bAOuIAcYan0,775
+universal_mcp/utils/testing.py,sha256=Crk1OqHjXSHIMfPquIuzL4NBq7x1RxL4roTpJobDoY4,1464
+universal_mcp/utils/openapi/__inti__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/utils/openapi/api_generator.py,sha256=bX4nAZCZLh4cOO5deLh7MqJ3p3ZWOzggQsCwhUaFMb4,5696
+universal_mcp/utils/openapi/api_splitter.py,sha256=io7fV-E8hUIR4NxFlakqydbgrQF6aBAnZHPMlpxw-wc,20967
+universal_mcp/utils/openapi/cli.py,sha256=oQe8KzVa7OEe-ruJRaDlmKmhppEMb15qHyqbDc0QAAM,8715
+universal_mcp/utils/openapi/docgen.py,sha256=DNmwlhg_-TRrHa74epyErMTRjV2nutfCQ7seb_Rq5hE,21366
+universal_mcp/utils/openapi/filters.py,sha256=96FajO5nLbvjNPy2A1HvSS9jqpzMDHd4q_QTP-DIsPI,3842
+universal_mcp/utils/openapi/openapi.py,sha256=xAzr7V1PHBPbRhGrjNoBxT1clvTL7y_9BghvYgEvBqw,52406
+universal_mcp/utils/openapi/preprocessor.py,sha256=OYlJX9BOn-lBFmBEOii3S2_Vdp3EGXVu3Qc3vLXtGRI,63087
+universal_mcp/utils/openapi/readme.py,sha256=R2Jp7DUXYNsXPDV6eFTkLiy7MXbSULUj1vHh4O_nB4c,2974
+universal_mcp/utils/templates/README.md.j2,sha256=Mrm181YX-o_-WEfKs01Bi2RJy43rBiq2j6fTtbWgbTA,401
+universal_mcp/utils/templates/api_client.py.j2,sha256=972Im7LNUAq3yZTfwDcgivnb-b8u6_JLKWXwoIwXXXQ,908
+universal_mcp-0.1.24rc2.dist-info/METADATA,sha256=YiW1lPdirDqFJDTvpi5Ah-INW9p0_btzqiSKE2kQrxA,2546
+universal_mcp-0.1.24rc2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp-0.1.24rc2.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
+universal_mcp-0.1.24rc2.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
+universal_mcp-0.1.24rc2.dist-info/RECORD,,

universal_mcp/applications/README.md

@@ -1,122 +0,0 @@
-# Universal MCP Applications Module
-
-This module provides the core functionality for managing and integrating applications within the Universal MCP system. It offers a flexible framework for creating, managing, and interacting with various types of applications through a unified interface.
-
-## Overview
-
-The applications module provides three main base classes for building application integrations:
-
-1. `BaseApplication`: The abstract base class that defines the common interface for all applications
-2. `APIApplication`: A concrete implementation for applications that communicate via HTTP APIs
-3. `GraphQLApplication`: A specialized implementation for applications that use GraphQL APIs
-
-## Key Features
-
-- **Dynamic Application Loading**: Applications can be loaded dynamically from external packages
-- **Unified Credential Management**: Centralized handling of application credentials
-- **HTTP API Support**: Built-in support for RESTful API interactions
-- **GraphQL Support**: Specialized support for GraphQL-based applications
-- **Automatic Package Installation**: Automatic installation of application packages from GitHub
-
-## Base Classes
-
-### BaseApplication
-
-The foundation class for all applications, providing:
-- Basic initialization
-- Credential management
-- Tool listing interface
-
-### APIApplication
-
-Extends BaseApplication to provide:
-- HTTP client management
-- Authentication handling
-- Common HTTP methods (GET, POST, PUT, DELETE, PATCH)
-- Request/response handling
-
-### GraphQLApplication
-
-Specialized for GraphQL-based applications, offering:
-- GraphQL client management
-- Query and mutation execution
-- Authentication handling
-
-## Usage
-
-### Creating a New Application
-
-1. Create a new package following the naming convention: `universal_mcp_<app_name>`
-2. Implement your application class inheriting from one of the base classes
-3. Name your class following the convention: `<AppName>App`
-
-Example:
-```python
-from universal_mcp.applications import APIApplication
-
-class MyApp(APIApplication):
-    def __init__(self, name: str, integration=None, **kwargs):
-        super().__init__(name, integration, **kwargs)
-        self.base_url = "https://api.example.com"
-
-    def list_tools(self):
-        return [self.my_tool]
-
-    def my_tool(self):
-        # Implementation here
-        pass
-```
-
-### Loading an Application
-
-```python
-from universal_mcp.applications import app_from_slug
-
-# The system will automatically install the package if needed
-MyApp = app_from_slug("my-app")
-app = MyApp("my-app-instance")
-```
-
-## Authentication
-
-The module supports various authentication methods:
-- API Keys
-- Access Tokens
-- Custom Headers
-- Bearer Tokens
-
-Credentials are managed through the integration system and can be accessed via the `credentials` property.
-
-## Error Handling
-
-The module includes comprehensive error handling for:
-- Package installation failures
-- Import errors
-- API request failures
-- Authentication issues
-
-## Logging
-
-All operations are logged using the `loguru` logger, providing detailed information about:
-- Application initialization
-- API requests
-- Authentication attempts
-- Package installation
-- Error conditions
-
-## Requirements
-
-- Python 3.8+
-- httpx
-- gql
-- loguru
-- uv (for package installation)
-
-## Contributing
-
-To contribute a new application:
-1. Create a new package following the naming conventions
-2. Implement the application class
-3. Add proper error handling and logging
-4. Include comprehensive documentation
-5. Submit a pull request to the Universal MCP repository

universal_mcp/client/__main__.py

@@ -1,30 +0,0 @@
-import asyncio
-import os
-import sys
-
-from loguru import logger
-from pydantic import ValidationError
-
-from universal_mcp.client.agent import ChatSession
-from universal_mcp.client.client import MultiClientServer
-from universal_mcp.config import ClientConfig
-
-
-async def main() -> None:
-    """Initialize and run the chat session."""
-    # Load settings and config using Pydantic BaseSettings
-
-    config_path = os.getenv("MCP_CONFIG_PATH", "servers.json")
-    try:
-        app_config = ClientConfig.load_json_config(config_path)
-    except (FileNotFoundError, ValidationError) as e:
-        logger.error(f"Error loading config: {e}")
-        sys.exit(1)
-
-    async with MultiClientServer(app_config.mcpServers) as mcp_server:
-        chat_session = ChatSession(mcp_server, app_config.llm)
-        await chat_session.interactive_loop()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

universal_mcp/client/agent.py

@@ -1,96 +0,0 @@
-import json
-
-from loguru import logger
-from mcp.server import Server as MCPServer
-from openai import AsyncOpenAI
-
-from universal_mcp.config import LLMConfig
-
-
-class ChatSession:
-    """Orchestrates the interaction between user, LLM, and tools."""
-
-    def __init__(self, mcp_server: MCPServer, llm: LLMConfig | None) -> None:
-        self.mcp_server: MCPServer = mcp_server
-        self.llm: AsyncOpenAI | None = AsyncOpenAI(api_key=llm.api_key, base_url=llm.base_url) if llm else None
-        self.model = llm.model if llm else None
-
-    async def run(self, messages, tools) -> None:
-        """Run the chat session."""
-        llm_response = await self.llm.chat.completions.create(
-            model=self.model,
-            messages=messages,
-            tools=tools,
-            tool_choice="auto",
-        )
-
-        tool_calls = llm_response.choices[0].message.tool_calls
-        if tool_calls:
-            for tool_call in tool_calls:
-                result = await self.mcp_server.call_tool(
-                    tool_name=tool_call.function.name,
-                    arguments=json.loads(tool_call.function.arguments) if tool_call.function.arguments else {},
-                )
-                result_content = [rc.text for rc in result.content] if result.content else "No result"
-                messages.append(
-                    {
-                        "tool_call_id": tool_call.id,
-                        "role": "tool",
-                        "name": tool_call.function.name,
-                        "content": result_content,
-                    }
-                )
-        else:
-            messages.append(llm_response.choices[0].message)
-        return messages
-
-    async def interactive_loop(self) -> None:
-        """Main chat session handler."""
-        all_openai_tools = await self.mcp_server.list_tools(format="openai")
-        system_message = "You are a helpful assistant"
-        messages = [{"role": "system", "content": system_message}]
-
-        print("\n🎯 Interactive MCP Client")
-        print("Commands:")
-        print("  list - List available tools")
-        print("  call <tool_name> [args] - Call a tool")
-        print("  quit - Exit the client")
-        print()
-        while True:
-            try:
-                user_input = input("You: ").strip()
-                if user_input.lower() in {"quit", "exit"}:
-                    logger.info("\nExiting...")
-                    break
-                elif user_input.lower() == "list":
-                    tools = await self.mcp_server.list_tools()
-                    print("\nAvailable tools:")
-                    for tool in tools:
-                        print(f"  {tool.name}")
-                    continue
-                elif user_input.startswith("call "):
-                    parts = user_input.split(maxsplit=2)
-                    tool_name = parts[1] if len(parts) > 1 else ""
-
-                    if not tool_name:
-                        print("❌ Please specify a tool name")
-                        continue
-
-                    # Parse arguments (simple JSON-like format)
-                    arguments = {}
-                    if len(parts) > 2:
-                        try:
-                            arguments = json.loads(parts[2])
-                        except json.JSONDecodeError:
-                            print("❌ Invalid arguments format (expected JSON)")
-                            continue
-                    await self.mcp_server.call_tool(tool_name, arguments)
-
-                messages.append({"role": "user", "content": user_input})
-
-                messages = await self.run(messages, all_openai_tools)
-                print("\nAssistant: ", messages[-1]["content"])
-
-            except KeyboardInterrupt:
-                print("\nExiting...")
-                break

universal_mcp/integrations/README.md

@@ -1,25 +0,0 @@
-# Integrations
-
-This package provides integration classes for handling authentication and authorization with external services.
-
-## Overview
-
-An Integration defines how an application authenticates and authorizes with a service provider. The base `Integration` class provides an interface that all integrations must implement.
-
-## Supported Integrations
-
-### AgentR Integration
-The `AgentRIntegration` class handles OAuth-based authentication flow with the AgentR API. It requires an API key which can be obtained from [agentr.dev](https://agentr.dev).
-
-### API Key Integration  
-The `ApiKeyIntegration` class provides a simple API key based authentication mechanism. API keys are configured via environment variables.
-
-## Usage
-
-Each integration implements three key methods:
-
-- `authorize()` - Initiates the authorization flow
-- `get_credentials()` - Retrieves stored credentials
-- `set_credentials()` - Stores new credentials
-
-See the individual integration classes for specific usage details.

universal_mcp/servers/README.md

@@ -1,79 +0,0 @@
-# Servers
-
-This package provides server implementations for hosting and managing MCP (Model Control Protocol) applications.
-
-## Overview
-
-The server implementations provide different ways to host and expose MCP applications and their tools. The base `BaseServer` class provides common functionality that all server implementations inherit.
-
-## Supported Server Types
-
-### Local Server
-The `LocalServer` class provides a local development server implementation that:
-- Loads applications from local configuration
-- Manages a local store for data persistence
-- Supports integration with external services
-- Exposes application tools through the MCP protocol
-
-### AgentR Server
-The `AgentRServer` class provides a server implementation that:
-- Connects to the AgentR API
-- Dynamically fetches and loads available applications
-- Manages AgentR-specific integrations
-- Requires an API key for authentication
-
-### Single MCP Server
-The `SingleMCPServer` class provides a minimal server implementation that:
-- Hosts a single application instance
-- Ideal for development and testing
-- Does not manage integrations or stores internally
-- Exposes only the tools from the provided application
-
-## Core Features
-
-All server implementations provide:
-
-- Tool management and registration
-- Application loading and configuration
-- Error handling and logging
-- MCP protocol compliance
-- Integration support
-
-## Usage
-
-Each server implementation can be initialized with a `ServerConfig` object that specifies:
-- Server name and description
-- Port configuration
-- Application configurations
-- Store configuration (where applicable)
-
-Example:
-```python
-from universal_mcp.servers import LocalServer
-from universal_mcp.config import ServerConfig
-
-config = ServerConfig(
-    name="My Local Server",
-    description="Development server for testing applications",
-    port=8000,
-    # ... additional configuration
-)
-
-server = LocalServer(config)
-```
-
-## Tool Management
-
-Servers provide methods for:
-- Adding individual tools
-- Listing available tools
-- Calling tools with proper error handling
-- Formatting tool results
-
-## Error Handling
-
-All servers implement comprehensive error handling for:
-- Tool execution failures
-- Application loading errors
-- Integration setup issues
-- API communication problems

universal_mcp/stores/README.md

@@ -1,74 +0,0 @@
-# Universal MCP Stores
-
-The stores module provides a flexible and secure way to manage credentials and sensitive data across different storage backends. It implements a common interface for storing, retrieving, and deleting sensitive information.
-
-## Features
-
-- Abstract base class defining a consistent interface for credential stores
-- Multiple storage backend implementations:
-  - In-memory store (temporary storage)
-  - Environment variable store
-  - System keyring store (secure credential storage)
-- Exception handling for common error cases
-- Type hints and comprehensive documentation
-
-## Available Store Implementations
-
-### MemoryStore
-A simple in-memory store that persists data only for the duration of program execution. Useful for testing or temporary storage.
-
-```python
-from universal_mcp.stores import MemoryStore
-
-store = MemoryStore()
-store.set("api_key", "secret123")
-value = store.get("api_key")  # Returns "secret123"
-```
-
-### EnvironmentStore
-Uses environment variables to store and retrieve credentials. Useful for containerized environments or CI/CD pipelines.
-
-```python
-from universal_mcp.stores import EnvironmentStore
-
-store = EnvironmentStore()
-store.set("API_KEY", "secret123")
-value = store.get("API_KEY")  # Returns "secret123"
-```
-
-### KeyringStore
-Leverages the system's secure credential storage facility. Provides the most secure option for storing sensitive data.
-
-```python
-from universal_mcp.stores import KeyringStore
-
-store = KeyringStore(app_name="my_app")
-store.set("api_key", "secret123")
-value = store.get("api_key")  # Returns "secret123"
-```
-
-## Error Handling
-
-The module provides specific exception types for handling errors:
-
-- `StoreError`: Base exception for all store-related errors
-- `KeyNotFoundError`: Raised when a requested key is not found in the store
-
-## Best Practices
-
-1. Use `KeyringStore` for production environments where security is a priority
-2. Use `EnvironmentStore` for containerized or cloud environments
-3. Use `MemoryStore` for testing or temporary storage only
-4. Always handle `StoreError` and `KeyNotFoundError` exceptions appropriately
-
-## Dependencies
-
-- `keyring`: Required for the KeyringStore implementation
-- `loguru`: Used for logging operations in the KeyringStore
-
-## Contributing
-
-New store implementations should inherit from `BaseStore` and implement all required abstract methods:
-- `get(key: str) -> Any`
-- `set(key: str, value: str) -> None`
-- `delete(key: str) -> None`

universal_mcp/tools/README.md

@@ -1,86 +0,0 @@
-# Universal MCP Tools
-
-This directory contains the core tooling infrastructure for Universal MCP, providing a flexible and extensible framework for defining, managing, and converting tools across different formats.
-
-## Components
-
-### `tools.py`
-The main module containing the core tool management functionality:
-
-- `Tool` class: Represents a tool with metadata, validation, and execution capabilities
-- `ToolManager` class: Manages tool registration, lookup, and execution
-- Conversion utilities for different tool formats (OpenAI, LangChain, MCP)
-
-### `adapters.py`
-Contains adapters for converting tools between different formats:
-- `convert_tool_to_mcp_tool`: Converts a tool to MCP format
-- `convert_tool_to_langchain_tool`: Converts a tool to LangChain format
-
-### `func_metadata.py`
-Provides function metadata and argument validation:
-- `FuncMetadata` class: Handles function signature analysis and argument validation
-- `ArgModelBase` class: Base model for function arguments
-- Utilities for parsing and validating function signatures
-
-## Usage
-
-### Creating a Tool
-
-```python
-from universal_mcp.tools import Tool
-
-def my_tool(param1: str, param2: int) -> str:
-    """A simple tool that does something.
-    
-    Args:
-        param1: Description of param1
-        param2: Description of param2
-        
-    Returns:
-        Description of return value
-    """
-    return f"Result: {param1} {param2}"
-
-tool = Tool.from_function(my_tool)
-```
-
-### Managing Tools
-
-```python
-from universal_mcp.tools import ToolManager
-
-manager = ToolManager()
-manager.add_tool(my_tool)
-
-# Get a tool by name
-tool = manager.get_tool("my_tool")
-
-# List all tools in a specific format
-tools = manager.list_tools(format="openai")  # or "langchain" or "mcp"
-```
-
-### Converting Tools
-
-```python
-from universal_mcp.tools import convert_tool_to_langchain_tool
-
-langchain_tool = convert_tool_to_langchain_tool(tool)
-```
-
-## Features
-
-- Automatic docstring parsing for tool metadata
-- Type validation using Pydantic
-- Support for both sync and async tools
-- JSON schema generation for tool parameters
-- Error handling and analytics tracking
-- Tag-based tool organization
-- Multiple format support (OpenAI, LangChain, MCP)
-
-## Best Practices
-
-1. Always provide clear docstrings for your tools
-2. Use type hints for better validation
-3. Handle errors appropriately in your tool implementations
-4. Use tags to organize related tools
-5. Consider async implementations for I/O-bound operations