universal-mcp 0.1.0__py3-none-any.whl

universal_mcp/utils/openapi.py

@@ -0,0 +1,274 @@
+import json
+import yaml
+import re
+from pathlib import Path
+
+
+def convert_to_snake_case(identifier: str) -> str:
+    """
+    Convert a camelCase or PascalCase identifier to snake_case.
+    
+    Args:
+        identifier (str): The string to convert
+        
+    Returns:
+        str: The converted snake_case string
+    """
+    if not identifier:
+        return identifier
+    # Add underscore between lowercase and uppercase letters
+    result = re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', identifier)
+    # Convert to lowercase
+    return result.lower()
+
+
+def load_schema(path: Path):
+    if path.suffix == '.yaml':
+        type = 'yaml'
+    else:
+        type = 'json'
+    with open(path, 'r') as f:
+        if type == 'yaml':
+            return yaml.safe_load(f)
+        else:
+            return json.load(f)
+
+
+def generate_api_client(schema):
+    """
+    Generate a Python API client class from an OpenAPI schema.
+    
+    Args:
+        schema (dict): The OpenAPI schema as a dictionary.
+    
+    Returns:
+        str: A string containing the Python code for the API client class.
+    """
+    methods = []
+    method_names = []
+    
+    # Extract API info for naming and base URL
+    info = schema.get('info', {})
+    api_title = info.get('title', 'API')
+    
+    # Get base URL from servers array if available
+    base_url = ""
+    servers = schema.get('servers', [])
+    if servers and isinstance(servers, list) and 'url' in servers[0]:
+        base_url = servers[0]['url'].rstrip('/')
+    
+    # Create a clean class name from API title
+    if api_title:
+        # Convert API title to a clean class name
+        base_name = "".join(word.capitalize() for word in api_title.split())
+        clean_name = ''.join(c for c in base_name if c.isalnum())
+        class_name = f"{clean_name}App"
+    else:
+        class_name = "APIClient"
+    
+    # Iterate over paths and their operations
+    for path, path_info in schema.get('paths', {}).items():
+        for method in path_info:
+            if method in ['get', 'post', 'put', 'delete', 'patch', 'options', 'head']:
+                operation = path_info[method]
+                method_code, func_name = generate_method_code(path, method, operation)
+                methods.append(method_code)
+                method_names.append(func_name)
+    
+    # Generate list_tools method with all the function names
+    tools_list = ",\n            ".join([f"self.{name}" for name in method_names])
+    list_tools_method = f"""    def list_tools(self):
+        return [
+            {tools_list}
+        ]"""
+    
+    # Generate class imports
+    imports = [
+        "from universal_mcp.applications import APIApplication",
+        "from universal_mcp.integrations import Integration",
+        "from typing import Any, Dict"
+    ]
+    
+    # Construct the class code
+    class_code = (
+        "\n".join(imports) + "\n\n"
+        f"class {class_name}(APIApplication):\n"
+        f"    def __init__(self, integration: Integration = None, **kwargs) -> None:\n"
+        f"        super().__init__(name='{class_name.lower()}', integration=integration, **kwargs)\n"
+        f"        self.base_url = \"{base_url}\"\n\n" +
+        '\n\n'.join(methods) + "\n\n" +
+        list_tools_method + "\n"
+    )
+    return class_code
+
+
+def generate_method_code(path, method, operation):
+    """
+    Generate the code for a single API method.
+    
+    Args:
+        path (str): The API path (e.g., '/users/{user_id}').
+        method (str): The HTTP method (e.g., 'get').
+        operation (dict): The operation details from the schema.
+    
+    Returns:
+        tuple: (method_code, func_name) - The Python code for the method and its name.
+    """
+    # Determine function name
+    if 'operationId' in operation:
+        raw_name = operation['operationId']
+        cleaned_name = raw_name.replace('.', '_').replace('-', '_')
+        func_name = convert_to_snake_case(cleaned_name)
+    else:
+        # Generate name from path and method
+        path_parts = path.strip('/').split('/')
+        name_parts = [method]
+        for part in path_parts:
+            if part.startswith('{') and part.endswith('}'):
+                name_parts.append('by_' + part[1:-1])
+            else:
+                name_parts.append(part)
+        func_name = '_'.join(name_parts).replace('-', '_').lower()
+    
+    # Get parameters and request body
+    parameters = operation.get('parameters', [])
+    has_body = 'requestBody' in operation
+    body_required = has_body and operation['requestBody'].get('required', False)
+    
+    # Build function arguments
+    args = []
+    for param in parameters:
+        if param.get('required', False):
+            args.append(param['name'])
+        else:
+            args.append(f"{param['name']}=None")
+    
+    if has_body:
+        args.append('request_body' if body_required else 'request_body=None')
+    
+    signature = f"    def {func_name}(self, {', '.join(args)}) -> Dict[str, Any]:"
+    
+    # Build method body
+    body_lines = []
+    
+    # Validate required parameters
+    for param in parameters:
+        if param.get('required', False):
+            body_lines.append(f"        if {param['name']} is None:")
+            body_lines.append(f"            raise ValueError(\"Missing required parameter '{param['name']}'\")")
+    
+    # Validate required body
+    if has_body and body_required:
+        body_lines.append("        if request_body is None:")
+        body_lines.append("            raise ValueError(\"Missing required request body\")")
+    
+    # Path parameters
+    path_params = [p for p in parameters if p['in'] == 'path']
+    path_params_dict = ', '.join([f"'{p['name']}': {p['name']}" for p in path_params])
+    body_lines.append(f"        path_params = {{{path_params_dict}}}")
+    
+    # Format URL
+    body_lines.append(f"        url = f\"{{self.base_url}}{path}\".format_map(path_params)")
+    
+    # Query parameters
+    query_params = [p for p in parameters if p['in'] == 'query']
+    query_params_items = ', '.join([f"('{p['name']}', {p['name']})" for p in query_params])
+    body_lines.append(
+        f"        query_params = {{k: v for k, v in [{query_params_items}] if v is not None}}"
+    )
+    
+    # Request body handling for JSON
+    if has_body:
+        body_lines.append("        json_body = request_body if request_body is not None else None")
+    
+    # Make HTTP request using the proper method
+    method_lower = method.lower()
+    if method_lower == 'get':
+        body_lines.append("        response = self._get(url, params=query_params)")
+    elif method_lower == 'post':
+        if has_body:
+            body_lines.append("        response = self._post(url, data=json_body)")
+        else:
+            body_lines.append("        response = self._post(url, data={})")
+    elif method_lower == 'put':
+        if has_body:
+            body_lines.append("        response = self._put(url, data=json_body)")
+        else:
+            body_lines.append("        response = self._put(url, data={})")
+    elif method_lower == 'delete':
+        body_lines.append("        response = self._delete(url)")
+    else:
+        body_lines.append(f"        response = self._{method_lower}(url, data={{}})")
+    
+    # Handle response
+    body_lines.append("        response.raise_for_status()")
+    body_lines.append("        return response.json()")
+    
+    method_code = signature + '\n' + '\n'.join(body_lines)
+    return method_code, func_name
+
+
+# Example usage
+if __name__ == "__main__":
+    # Sample OpenAPI schema
+    schema = {
+        "paths": {
+            "/users": {
+                "get": {
+                    "summary": "Get a list of users",
+                    "parameters": [
+                        {
+                            "name": "limit",
+                            "in": "query",
+                            "required": False,
+                            "schema": {"type": "integer"}
+                        }
+                    ],
+                    "responses": {
+                        "200": {
+                            "description": "A list of users",
+                            "content": {"application/json": {"schema": {"type": "array"}}}
+                        }
+                    }
+                },
+                "post": {
+                    "summary": "Create a user",
+                    "requestBody": {
+                        "required": True,
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "properties": {"name": {"type": "string"}}
+                                }
+                            }
+                        }
+                    },
+                    "responses": {
+                        "201": {"description": "User created"}
+                    }
+                }
+            },
+            "/users/{user_id}": {
+                "get": {
+                    "summary": "Get a user by ID",
+                    "parameters": [
+                        {
+                            "name": "user_id",
+                            "in": "path",
+                            "required": True,
+                            "schema": {"type": "string"}
+                        }
+                    ],
+                    "responses": {
+                        "200": {"description": "User details"}
+                    }
+                }
+            }
+        }
+    }
+    
+
+    schema = load_schema('openapi.yaml')
+    code = generate_api_client(schema)
+    print(code)

universal_mcp-0.1.0.dist-info/METADATA

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: universal-mcp
+Version: 0.1.0
+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>
+Requires-Python: >=3.11
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: mcp>=1.5.0
+Requires-Dist: pydantic-settings>=2.8.1
+Requires-Dist: pydantic>=2.11.1
+Requires-Dist: pyyaml>=6.0.2
+Requires-Dist: typer>=0.15.2
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.26.0; extra == 'test'
+Requires-Dist: pytest>=8.3.5; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Universal MCP
+
+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.
+
+
+## 🌟 Features
+
+- **MCP (Model Context Protocol) Integration**: Seamlessly works with MCP server architecture
+- **Simplified API Integration**: Connect to services like GitHub, Google Calendar, Gmail, Reddit, Tavily, and more with minimal code
+- **Managed Authentication**: Built-in support for API keys and OAuth-based authentication flows
+- **Extensible Architecture**: Easily build and add new app integrations with minimal boilerplate
+- **Credential Management**: Flexible storage options for API credentials with memory and environment-based implementations
+
+## 🔧 Installation
+
+Install AgentR using pip:
+
+```bash
+pip install universal-mcp
+```
+
+## 🚀 Quick Start
+
+### 1. Get an API Key
+Before using AgentR with services that require authorization (like GitHub, Gmail, etc.), you'll need an AgentR API key:
+
+Visit https://agentr.dev to create an account
+Generate an API key from your dashboard
+Set it as an environment variable or include it directly in your code:
+
+```bash
+export AGENTR_API_KEY="your_api_key_here"
+```
+
+### 2. Create a basic server
+
+```bash
+from agentr.server import TestServer
+
+# Define your applications list
+apps_list = [
+    {
+        "name": "tavily",
+        "integration": {
+            "name": "tavily_api_key",
+            "type": "api_key",
+            "store": {
+                "type": "environment",
+            }
+        },        
+    },
+    {
+        "name": "zenquotes",
+        "integration": None
+    },
+    {
+        "name": "github",
+        "integration": {
+            "name": "github",
+            "type": "agentr",
+        }
+    }
+]
+
+# Create a server with these applications
+server = TestServer(name="My Agent Server", description="A server for my agent apps", apps_list=apps_list)
+
+# Run the server
+if __name__ == "__main__":
+    server.run()
+```
+
+## 🧩 Available Applications
+AgentR comes with several pre-built applications:
+
+| Application | Description | Authentication Type |
+|-------------|-------------|---------------------|
+| GitHub | Star repositories and more | OAuth (AgentR) |
+| Google Calendar | Retrieve calendar events | OAuth (AgentR) |
+| Gmail | Send emails | OAuth (AgentR) |
+| Reddit | Access Reddit data | OAuth (AgentR) |
+| Resend | Send emails via Resend API | API Key |
+| Tavily | Web search capabilities | API Key |
+| ZenQuotes | Get inspirational quotes | None |
+
+> **Note**: More applications are coming soon! Stay tuned for updates to our application catalog.
+
+## 🔐 Integration Types
+AgentR supports two primary integration types:
+
+### 1. API Key Integration
+For services that authenticate via API keys:
+```python
+{
+    "name": "service_name",
+    "integration": {
+        "name": "service_api_key",
+        "type": "api_key",
+        "store": {
+            "type": "environment",  # or "memory"
+        }
+    }
+}
+```
+
+### 2. OAuth Integration (via AgentR)
+For services requiring OAuth flow:
+```python
+{
+    "name": "service_name",
+    "integration": {
+        "name": "service_name",
+        "type": "agentr"
+    }
+}
+```
+When using OAuth integrations, users will be directed to authenticate with the service provider through a secure flow managed by AgentR.
+
+## 🤖 CLI Usage
+AgentR includes a command-line interface for common operations:
+
+```bash
+# Get version information
+agentr version
+
+# Generate API client from OpenAPI schema
+agentr generate --schema path/to/openapi.yaml
+
+# Run the test server
+agentr run
+
+# Install AgentR for specific applications
+agentr install claude
+```
+
+## 📋 Requirements
+
+- Python 3.11+
+- Dependencies (automatically installed):
+  - loguru >= 0.7.3
+  - mcp >= 1.5.0
+  - pyyaml >= 6.0.2
+  - typer >= 0.15.2
+
+
+## 📝 License
+
+This project is licensed under the MIT License.

universal_mcp-0.1.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+universal_mcp/__init__.py,sha256=2gdHpHaDDcsRjZjJ01FLN-1iidN_wbDAolNpxhGoFB4,59
+universal_mcp/cli.py,sha256=vbhiDfxnsJcMKhSpJyEA-YemrnlHgEMZ7BZll9pH8Xk,4152
+universal_mcp/config.py,sha256=YTygfFJPUuL-epRuILvt5tc5ACzByWIFFNhpFwHlDCE,387
+universal_mcp/exceptions.py,sha256=cPpdoioDrtNXD6QvH_GKs7bcQ5XRfX8wTrklC4mLS2g,273
+universal_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/applications/__init__.py,sha256=8X1y7kzqBRYsx7vP5jKSagyi4wa5hkbj6d8f8XanKU4,1132
+universal_mcp/applications/agentr.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/applications/application.py,sha256=gHVR7jS0SusNiIm98yoy6RpR-uJsgnvYNa_6DanaPsY,3409
+universal_mcp/applications/github/app.py,sha256=yXVukXPvAtTAuwNRjo6VU_bt52Sp91P3-K7GUpa3jt4,14020
+universal_mcp/applications/google_calendar/app.py,sha256=tovWxCW6YM2DiXM7aEZyA7_u2w2IHlcGcvmj3NsQzyA,19897
+universal_mcp/applications/google_mail/app.py,sha256=AiTj3uv_fX5J9d5aoIj3zNfhq2y2FRqCfonw3DUuFiY,23745
+universal_mcp/applications/reddit/app.py,sha256=MaHjqgmkHEaJMh3UMvAx4J6HtWQyWA8kOglk699AnlY,13317
+universal_mcp/applications/resend/app.py,sha256=Zy702XAxjL4_X_JxHv-3gFfEFZznHdazgde-Z9102S8,1456
+universal_mcp/applications/tavily/app.py,sha256=d8mSUzvgzBA07WTzMLEKbFNwGpzEeVWGczJKnvu_2aQ,1833
+universal_mcp/applications/zenquotes/app.py,sha256=S86lTiIypXkDqx3kbc3Couk5L_7ejH-Qy-gLTLcCfwM,627
+universal_mcp/integrations/README.md,sha256=lTAPXO2nivcBe1q7JT6PRa6v9Ns_ZersQMIdw-nmwEA,996
+universal_mcp/integrations/__init__.py,sha256=frBUL7zHnCeukXLuGL8g2P8Rx7D_1TryJQFKKZE2mT4,252
+universal_mcp/integrations/agentr.py,sha256=wmac5vwMvftv8PWR54_42fYGlQloFejx76e-vxa597Q,3385
+universal_mcp/integrations/integration.py,sha256=R4yATIL6JcuPmFZQknQgWv9mb5eGIcpoismOx2VkKPs,4647
+universal_mcp/servers/__init__.py,sha256=IA9hGn0pebJx4hzTdcsRlH4rPD6BAeuw-7VG_WlRzFw,105
+universal_mcp/servers/server.py,sha256=RzqX0slJOzgU9rxJJECEHQyVGNUAlAeDaOrLrtdwXRc,5276
+universal_mcp/stores/__init__.py,sha256=2_qV1Np4GIrFPdH5CIKLeXEXn2b_ImoOTXmaEuHLc6g,135
+universal_mcp/stores/store.py,sha256=fB3uAaobnWf2ILcDBmg3ToDaqAIPYlLtmHBdpmkcGcI,1585
+universal_mcp/utils/bridge.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/utils/openapi.py,sha256=YvDAUohGkcUf2j1-C9jXCF9DaM4ovnr2NlwejFRxGdI,9590
+universal_mcp-0.1.0.dist-info/METADATA,sha256=pRUC64lsW_p2E9lBiRnQe_SnjIcbWkr1N1enzRGFMNY,4506
+universal_mcp-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp-0.1.0.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
+universal_mcp-0.1.0.dist-info/RECORD,,

universal_mcp-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

universal_mcp-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+universal_mcp = universal_mcp.cli:app