universal-mcp 0.1.4__tar.gz → 0.1.24__tar.gz

{universal_mcp-0.1.4 → universal_mcp-0.1.24}/.gitignore

@@ -44,4 +44,17 @@ test_artifacts/
 src/universal_mcp/applications/complex/
 src/universal_mcp/applications/test/
 src/universal_mcp/applications/test_with_docs/
-src/universal_mcp/applications/test_without_docs/
+src/universal_mcp/applications/test_without_docs/
+
+# Temporary files
+tmp/
+
+
+# Docs
+site/
+.cache/
+
+# langgraph temporary files
+.langgraph_api/
+langgraph.json
+agentr-1-6c4ebd5cc914.json

universal_mcp-0.1.4/node_modules/styled-jsx/license.md → universal_mcp-0.1.24/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2016-present Vercel, Inc.
+Copyright (c) 2025 Agentr
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

universal_mcp-0.1.24/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: universal-mcp
+Version: 0.1.24
+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: agentevals>=0.0.9
+Requires-Dist: black>=25.1.0
+Requires-Dist: cookiecutter>=2.6.0
+Requires-Dist: gql>=4.0.0
+Requires-Dist: httpx-aiohttp>=0.1.8
+Requires-Dist: jinja2>=3.1.3
+Requires-Dist: jsonref>=1.1.0
+Requires-Dist: keyring>=25.6.0
+Requires-Dist: langchain-anthropic>=0.3.19
+Requires-Dist: langchain-google-genai>=2.1.10
+Requires-Dist: langchain-google-vertexai>=2.0.28
+Requires-Dist: langchain-mcp-adapters>=0.1.9
+Requires-Dist: langchain-openai>=0.3.27
+Requires-Dist: langgraph-cli[inmem]>=0.3.4
+Requires-Dist: langgraph>=0.5.2
+Requires-Dist: langsmith>=0.4.5
+Requires-Dist: loguru>=0.7.3
+Requires-Dist: mcp>=1.10.0
+Requires-Dist: openevals>=0.1.0
+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: streamlit>=1.46.1
+Requires-Dist: typer>=0.15.2
+Provides-Extra: dev
+Requires-Dist: litellm>=1.30.7; 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'
+Requires-Dist: ty>=0.0.1a17; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-glightbox>=0.4.0; extra == 'docs'
+Requires-Dist: mkdocs-material[imaging]>=9.5.45; extra == 'docs'
+Requires-Dist: mkdocs>=1.6.1; extra == 'docs'
+Requires-Dist: mkdocstrings-python>=1.12.2; extra == 'docs'
+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.24/README.md

@@ -0,0 +1,22 @@
+# 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.24/pyproject.toml

@@ -0,0 +1,114 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "universal-mcp"
+version = "0.1.24"
+description = "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."
+readme = "README.md"
+authors = [
+    { name = "Manoj Bajaj", email = "manojbajaj95@gmail.com" }
+]
+requires-python = ">=3.11"
+license = { text = "MIT" }
+dependencies = [
+    "Jinja2>=3.1.3",
+    "agentevals>=0.0.9",
+    "black>=25.1.0",
+    "cookiecutter>=2.6.0",
+    "gql>=4.0.0",
+    "httpx-aiohttp>=0.1.8",
+    "jsonref>=1.1.0",
+    "keyring>=25.6.0",
+    "langchain-anthropic>=0.3.19",
+    "langchain-google-genai>=2.1.10",
+    "langchain-google-vertexai>=2.0.28",
+    "langchain-mcp-adapters>=0.1.9",
+    "langchain-openai>=0.3.27",
+    "langgraph>=0.5.2",
+    "langgraph-cli[inmem]>=0.3.4",
+    "langsmith>=0.4.5",
+    "loguru>=0.7.3",
+    "mcp>=1.10.0",
+    "openevals>=0.1.0",
+    "posthog>=3.24.0",
+    "pydantic>=2.11.1",
+    "pydantic-settings>=2.8.1",
+    "pyyaml>=6.0.2",
+    "rich>=14.0.0",
+    "streamlit>=1.46.1",
+    "typer>=0.15.2",
+]
+
+[project.optional-dependencies]
+dev = [
+    "ty>=0.0.1a17",
+    "litellm>=1.30.7",
+    "pre-commit>=4.2.0",
+    "pyright>=1.1.398",
+    "pytest>=8.3.5",
+    "pytest-asyncio>=0.26.0",
+    "ruff>=0.11.4",
+]
+docs = [
+    "mkdocs>=1.6.1",
+    "mkdocs-glightbox>=0.4.0",
+    "mkdocs-material[imaging]>=9.5.45",
+    "mkdocstrings-python>=1.12.2",
+]
+
+[project.scripts]
+universal_mcp = "universal_mcp.cli:app"
+
+# ------------------------------
+# Hatch build configuration
+# ------------------------------
+[tool.hatch.build.targets.sdist]
+include = [
+    "/src",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/universal_mcp"]
+
+[tool.hatch.build.targets.wheel.shared-data]
+"templates" = "universal_mcp/templates"
+
+# ------------------------------
+# Tool configurations
+# ------------------------------
+[tool.ruff]
+line-length = 120
+indent-width = 4
+target-version = "py312"
+
+[tool.ruff.lint]
+select = [
+    "E",    # pycodestyle
+    "F",    # Pyflakes
+    "UP",   # pyupgrade
+    "B",    # flake8-bugbear
+    "SIM",  # flake8-simplify
+    "I",    # isort
+]
+ignore = ['E501', 'B008']
+fixable = ["ALL"]
+unfixable = []
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"
+docstring-code-line-length = "dynamic"
+
+[tool.pytest.ini_options]
+asyncio_mode = "strict"
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.mypy]
+exclude = [
+    '^src/universal_mcp/utils/openapi/\.*',
+]

universal_mcp-0.1.24/src/tests/conftest.py

@@ -0,0 +1,3 @@
+import os
+
+os.environ["TELEMETRY_DISABLED"] = "true"

{universal_mcp-0.1.4 → universal_mcp-0.1.24}/src/tests/test_api_generator.py

@@ -3,7 +3,7 @@ from pathlib import Path
 
 import pytest
 
-from universal_mcp.utils.api_generator import generate_api_from_schema
+from universal_mcp.utils.openapi.api_generator import generate_api_from_schema
 
 
 @pytest.fixture
@@ -24,6 +24,7 @@ def sample_schema(temp_dir):
                 "get": {
                     "operationId": "test_operation",
                     "summary": "Test operation",
+                    "tags": ["test", "operations"],
                     "responses": {
                         "200": {
                             "description": "Successful response",
@@ -52,11 +53,7 @@ def sample_schema(temp_dir):
 @pytest.mark.asyncio
 async def test_generate_api_without_output(sample_schema):
     """Test API generation without output file (return code only)."""
-    result = await generate_api_from_schema(
-        schema_path=sample_schema, 
-        output_path=None, 
-        add_docstrings=False
-    )
+    result = generate_api_from_schema(schema_path=sample_schema, output_path=None)
 
     assert "code" in result
     assert isinstance(result["code"], str)
@@ -73,17 +70,7 @@ async def test_generate_api_with_output(sample_schema, temp_dir):
     """Test API generation with output file."""
     output_path = temp_dir / "test.py"
 
-    result = await generate_api_from_schema(
-        schema_path=sample_schema, 
-        output_path=output_path, 
-        add_docstrings=True
-    )
-
-    assert "app_file" in result
-    assert "readme_file" in result
-
-    app_file = Path(result["app_file"])
-    readme_file = Path(result["readme_file"]) if result["readme_file"] else None
+    app_file, schemas_file = generate_api_from_schema(schema_path=sample_schema, output_path=output_path)
 
     assert app_file.exists()
     content = app_file.read_text()
@@ -93,17 +80,6 @@ async def test_generate_api_with_output(sample_schema, temp_dir):
     assert "def test_operation" in content
     assert "def list_tools" in content
 
-    # Verify README exists and contains expected content
-    if readme_file:
-        assert readme_file.exists()
-        readme_content = readme_file.read_text()
-        assert "Test MCP Server" in readme_content
-        assert "Tool List" in readme_content
-        assert "test_operation" in readme_content
-
-    # Verify temporary file was cleaned up
-    assert not output_path.exists()
-
 
 @pytest.mark.asyncio
 async def test_generate_api_invalid_schema(temp_dir):
@@ -119,37 +95,7 @@ async def test_generate_api_invalid_schema(temp_dir):
 async def test_generate_api_nonexistent_schema():
     """Test API generation with nonexistent schema file."""
     with pytest.raises(FileNotFoundError):
-        await generate_api_from_schema(
-            schema_path=Path("nonexistent.json"), output_path=None
-        )
-
-
-@pytest.mark.asyncio
-async def test_generate_api_with_docstrings(sample_schema, temp_dir):
-    """Test API generation with docstring generation."""
-    output_path = temp_dir / "test_with_docs.py"
-
-    result = await generate_api_from_schema(
-        schema_path=sample_schema, 
-        output_path=output_path, 
-        add_docstrings=True
-    )
-
-    app_file = Path(result["app_file"])
-    assert app_file.exists()
-
-    # Check if docstrings were added
-    content = app_file.read_text()
-    # Check for required imports and class structure
-    assert "from universal_mcp.applications import APIApplication" in content
-    assert "from universal_mcp.integrations import Integration" in content
-    assert "def test_operation" in content
-    assert '"""' in content  # Basic check for docstring presence
-    assert "Args:" in content or "Parameters:" in content
-    assert "Returns:" in content
-
-    # Verify temporary file was cleaned up
-    assert not output_path.exists()
+        await generate_api_from_schema(schema_path=Path("nonexistent.json"), output_path=None)
 
 
 @pytest.mark.asyncio
@@ -157,13 +103,8 @@ async def test_generate_api_without_docstrings(sample_schema, temp_dir):
     """Test API generation without docstring generation."""
     output_path = temp_dir / "test_without_docs.py"
 
-    result = await generate_api_from_schema(
-        schema_path=sample_schema, 
-        output_path=output_path, 
-        add_docstrings=False
-    )
+    app_file, schemas_file = generate_api_from_schema(schema_path=sample_schema, output_path=output_path)
 
-    app_file = Path(result["app_file"])
     assert app_file.exists()
 
     # Verify the app was generated
@@ -174,22 +115,6 @@ async def test_generate_api_without_docstrings(sample_schema, temp_dir):
     assert "def test_operation" in content
     assert "def list_tools" in content
 
-    # Verify temporary file was cleaned up
-    assert not output_path.exists()
-
-
-def test_applications_directory_structure():
-    """Test that the applications directory structure is correct."""
-    # Get the applications directory path
-    applications_dir = Path(__file__).parent.parent / "universal_mcp" / "applications"
-
-    # Check if applications directory exists
-    assert applications_dir.exists()
-    assert applications_dir.is_dir()
-
-    # Check if it's a Python package
-    assert (applications_dir / "__init__.py").exists()
-
 
 @pytest.mark.asyncio
 async def test_generate_api_with_complex_schema(temp_dir):
@@ -234,13 +159,8 @@ async def test_generate_api_with_complex_schema(temp_dir):
         json.dump(schema, f)
 
     output_path = temp_dir / "complex.py"
-    result = await generate_api_from_schema(
-        schema_path=schema_file, 
-        output_path=output_path, 
-        add_docstrings=True
-    )
+    app_file, schemas_file = generate_api_from_schema(schema_path=schema_file, output_path=output_path)
 
-    app_file = Path(result["app_file"])
     assert app_file.exists()
 
     content = app_file.read_text()
@@ -263,15 +183,3 @@ async def test_generate_api_with_complex_schema(temp_dir):
 
     # Check for proper typing imports
     assert "from typing import" in content
-
-    # Verify README was generated
-    readme_file = Path(result["readme_file"])
-    assert readme_file.exists()
-    readme_content = readme_file.read_text()
-
-    # Check README content
-    assert "Complex MCP Server" in readme_content
-    assert "Tool List" in readme_content
-    assert "list_users" in readme_content
-    assert "create_user" in readme_content
-    assert "get_user" in readme_content

universal_mcp-0.1.24/src/tests/test_apps.py

@@ -0,0 +1,64 @@
+import pytest
+
+from universal_mcp.applications.sample.app import SampleApp
+
+
+@pytest.mark.asyncio
+async def test_sample_app_initialization():
+    """Test that the SampleApp initializes correctly."""
+    app = SampleApp()
+
+    # Check app initialized
+    assert app is not None
+    assert app.name == "sample"
+
+
+@pytest.mark.asyncio
+async def test_sample_app_tools():
+    """Test that the SampleApp provides the expected tools."""
+    app = SampleApp()
+
+    # Get list of tools
+    tools = app.list_tools()
+
+    # Check that tools are available
+    assert len(tools) > 0
+
+    # Check specific tools exist
+    tool_names = [tool.__name__ for tool in tools]
+    expected_tools = [
+        "get_current_time",
+        "get_current_date",
+        "calculate",
+        "read_file",
+        "write_file",
+        "get_simple_weather",
+        "generate_image",
+    ]
+
+    for expected_tool in expected_tools:
+        assert expected_tool in tool_names
+
+
+@pytest.mark.asyncio
+async def test_sample_app_basic_functionality():
+    """Test basic functionality of SampleApp tools."""
+    app = SampleApp()
+
+    # Test get_current_time
+    current_time = app.get_current_time()
+    assert isinstance(current_time, str)
+    assert len(current_time) > 0
+
+    # Test get_current_date
+    current_date = app.get_current_date()
+    assert isinstance(current_date, str)
+    assert len(current_date) > 0
+
+    # Test calculate
+    result = app.calculate("2 + 2")
+    assert "Result: 4" in result
+
+    # Test calculate with error
+    error_result = app.calculate("invalid expression")
+    assert "Error in calculation" in error_result

universal_mcp-0.1.24/src/tests/test_local_registry.py

@@ -0,0 +1,94 @@
+import os
+import shutil
+
+import pytest
+from langchain_core.tools import StructuredTool
+from mcp.server.fastmcp.server import MCPTool
+
+from universal_mcp.exceptions import ToolNotFoundError
+from universal_mcp.tools.local_registry import LocalRegistry
+from universal_mcp.types import ToolFormat
+
+
+@pytest.fixture
+def registry():
+    """Provides a LocalRegistry instance and cleans up the output directory."""
+    output_dir = "test_output"
+    reg = LocalRegistry(output_dir=output_dir)
+    yield reg
+    # Cleanup the test output directory after tests are done
+    if os.path.exists(output_dir):
+        shutil.rmtree(output_dir)
+
+
+@pytest.mark.asyncio
+async def test_export_tools_formats(registry: LocalRegistry):
+    """Verify that tools are exported to all supported formats correctly."""
+    tool_names = ["sample__get_current_date", "sample__calculate"]
+
+    # Test MCP Format
+    mcp_tools = await registry.export_tools(tool_names, format=ToolFormat.MCP)
+    assert len(mcp_tools) == 2
+    assert all(isinstance(t, MCPTool) for t in mcp_tools)
+
+    # Test LangChain Format
+    langchain_tools = await registry.export_tools(tool_names, format=ToolFormat.LANGCHAIN)
+    assert len(langchain_tools) == 2
+    assert all(isinstance(t, StructuredTool) for t in langchain_tools)
+
+    # Test OpenAI Format
+    openai_tools = await registry.export_tools(tool_names, format=ToolFormat.OPENAI)
+    assert len(openai_tools) == 2
+    assert all(isinstance(t, dict) and t.get("type") == "function" for t in openai_tools)
+
+    # Test Native Format
+    native_tools = await registry.export_tools(tool_names, format=ToolFormat.NATIVE)
+    assert len(native_tools) == 2
+    assert all(callable(t) for t in native_tools)
+
+
+@pytest.mark.asyncio
+async def test_call_tool_success(registry: LocalRegistry):
+    """Test a successful tool call through the registry."""
+    await registry.export_tools(["sample__calculate"], format=ToolFormat.NATIVE)  # Load the tool
+    result = await registry.call_tool("sample__calculate", {"expression": "10 - 4"})
+    assert result == "Result: 6"
+
+
+@pytest.mark.asyncio
+async def test_call_tool_not_found(registry: LocalRegistry):
+    """Test that calling a non-existent tool raises the correct exception."""
+    with pytest.raises(ToolNotFoundError):
+        await registry.call_tool("nonexistent__tool", {})
+
+
+@pytest.mark.asyncio
+async def test_file_output_handling(registry: LocalRegistry):
+    """Test that file outputs are correctly handled by writing to a file."""
+    tool_name = "sample__generate_image"
+    await registry.export_tools([tool_name], format=ToolFormat.NATIVE)  # Load the tool
+
+    result = await registry.call_tool(tool_name, {"prompt": "testing file output"})
+    assert isinstance(result, str)
+    assert "File saved to:" in result
+
+    # Verify the file was actually created
+    file_path = result.split("File saved to: ")[1]
+    assert os.path.exists(file_path)
+
+
+@pytest.mark.asyncio
+async def test_unimplemented_methods(registry: LocalRegistry):
+    """Test that abstract methods raise NotImplementedError."""
+    with pytest.raises(NotImplementedError):
+        await registry.list_all_apps()
+    with pytest.raises(NotImplementedError):
+        await registry.get_app_details("some_app")
+    with pytest.raises(NotImplementedError):
+        await registry.search_apps("query")
+    with pytest.raises(NotImplementedError):
+        await registry.list_tools("some_app")
+    with pytest.raises(NotImplementedError):
+        await registry.search_tools("query")
+    with pytest.raises(NotImplementedError):
+        await registry.list_connected_apps()

universal_mcp-0.1.24/src/tests/test_localserver.py

@@ -0,0 +1,71 @@
+import pytest
+
+from universal_mcp.config import AppConfig, ServerConfig
+from universal_mcp.servers.server import LocalServer
+from universal_mcp.tools.local_registry import LocalRegistry
+
+
+@pytest.fixture
+def registry():
+    """Provides a fresh LocalRegistry for each test."""
+    return LocalRegistry()
+
+
+@pytest.mark.asyncio
+async def test_local_server_initialization(registry: LocalRegistry):
+    """Test that the server initializes correctly and loads default tools."""
+    apps_list = [AppConfig(name="sample")]
+    server_config = ServerConfig(apps=apps_list)
+    server = LocalServer(server_config, registry=registry)
+
+    assert server is not None
+    assert server.registry is registry
+
+    tools = await server.list_tools()
+    tool_names = {tool.name for tool in tools}
+
+    # By default, only "important" tools should be loaded
+    assert "sample__get_current_time" in tool_names
+    assert "sample__calculate" in tool_names
+    assert "sample__generate_image" in tool_names
+    # This tool is not tagged as important
+    assert "sample__get_simple_weather" not in tool_names
+
+
+@pytest.mark.asyncio
+async def test_local_server_loads_specific_actions(registry: LocalRegistry):
+    """Test that the server loads only the actions specified in the config."""
+    actions = ["get_current_date", "calculate"]
+    apps_list = [AppConfig(name="sample", actions=actions)]
+    server_config = ServerConfig(apps=apps_list)
+    server = LocalServer(server_config, registry=registry)
+
+    tools = await server.list_tools()
+    assert len(tools) == 2
+    tool_names = {tool.name for tool in tools}
+    assert tool_names == {"sample__get_current_date", "sample__calculate"}
+
+
+@pytest.mark.asyncio
+async def test_local_server_no_apps(registry: LocalRegistry):
+    """Test that the server handles a config with no apps gracefully."""
+    server_config = ServerConfig(apps=[])
+    server = LocalServer(server_config, registry=registry)
+
+    tools = await server.list_tools()
+    assert len(tools) == 0
+
+
+@pytest.mark.asyncio
+async def test_local_server_tool_call(registry: LocalRegistry):
+    """Test that a tool can be successfully called through the server."""
+    apps_list = [AppConfig(name="sample", actions=["get_current_date"])]
+    server_config = ServerConfig(apps=apps_list)
+    server = LocalServer(server_config, registry=registry)
+
+    # Test tool call
+    result = await server.call_tool("sample__get_current_date", {})
+    assert result is not None
+    # A basic check on the result format
+    assert isinstance(result[0].text, str)
+    assert "-" in result[0].text