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

universal_mcp/utils/testing.py

@@ -1,13 +1,48 @@
+import os
+from dataclasses import dataclass
+
+from langchain_core.messages import AIMessage, HumanMessage
+from langgraph.prebuilt import create_react_agent
 from loguru import logger
+from pydantic import BaseModel, SecretStr
+
+from universal_mcp.agentr import AgentrIntegration
+from universal_mcp.agentr.client import AgentrClient
+from universal_mcp.applications import APIApplication, BaseApplication
+from universal_mcp.tools import Tool, ToolManager
+from universal_mcp.types import ToolFormat
+
+
+class ValidateResult(BaseModel):
+    success: bool
+    reasoning: str
+
+
+def check_application_instance(app_instance: BaseApplication, app_name: str):
+    """
+    Performs a series of assertions to validate an application instance and its tools.
 
-from universal_mcp.tools.tools import Tool
+    This function checks for the following:
+    - The application instance is not None.
+    - The application instance's name matches the expected application name.
+    - The application has at least one tool.
+    - Each tool has a non-None name with a valid length (1-47 characters).
+    - Each tool has a non-None description.
+    - All tool names are unique within the application.
+    - The application has at least one tool tagged as "important".
 
+    Args:
+        app_instance: The application instance to check. Must be an instance of BaseApplication.
+        app_name: The expected name of the application.
+
+    Raises:
+        AssertionError: If any of the validation checks fail.
+    """
 
-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 +54,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}"
@@ -29,3 +64,156 @@ def check_application_instance(app_instance, app_name):
         if "important" in tool.tags:
             important_tools.append(tool.name)
     assert len(important_tools) > 0, f"No important tools found for {app_name}"
+
+
+@dataclass
+class AutomationTestCase:
+    """Generic test case for automation testing."""
+
+    app: str
+    app_instance: APIApplication | None = None
+    tools: list[str] | None = None
+    tasks: list[str] | None = None
+    validate_query: str | None = None
+
+
+def create_agentr_client(app_name: str) -> AgentrClient:
+    """
+    Create an AgentrClient with appropriate API key and base URL.
+
+    Args:
+        app_name: Name of the application (used for app-specific environment variables)
+
+    Returns:
+        AgentrClient instance
+    """
+    api_key = os.environ.get(f"{app_name.upper()}_API_KEY") or os.environ.get("AGENTR_API_KEY")
+    base_url = os.environ.get(f"{app_name.upper()}_BASE_URL") or os.environ.get(
+        "AGENTR_BASE_URL", "https://api.agentr.dev"
+    )
+    return AgentrClient(api_key=api_key, base_url=base_url)
+
+
+def create_integration(app_name: str) -> AgentrIntegration:
+    """
+    Create an AgentRIntegration instance with appropriate client.
+
+    Args:
+        app_name: Name of the application
+
+    Returns:
+        AgentRIntegration instance
+    """
+    client = create_agentr_client(app_name)
+    return AgentrIntegration(name=app_name, client=client)
+
+
+def create_app_with_integration(app_name: str, app_class: type[APIApplication]) -> APIApplication:
+    """
+    Create an application instance with integration.
+
+    Args:
+        app_name: Name of the application
+        app_class: Class of the application to instantiate
+
+    Returns:
+        Application instance with integration
+    """
+    integration = create_integration(app_name)
+    return app_class(integration=integration)
+
+
+def load_app_with_integration(app_name: str, app_class: type[APIApplication]) -> APIApplication:
+    """
+    Load application instance with real integration.
+
+    Args:
+        app_name: Name of the application
+        app_class: Class of the application to instantiate
+
+    Returns:
+        Instantiated application with integration
+    """
+    integration = create_integration(app_name)
+    return app_class(integration=integration)
+
+
+async def execute_automation_test(test_case: AutomationTestCase, app_instance: APIApplication | None = None) -> None:
+    """
+    Execute an automation test case using LangGraph ReAct agent.
+
+    Args:
+        test_case: Test case to execute
+        app_instance: The application instance to test (optional if provided in test_case)
+    """
+    tool_manager = ToolManager()
+
+    if app_instance is None:
+        app_instance = test_case.app_instance
+        if app_instance is None:
+            raise ValueError("No app_instance provided in test_case or as parameter")
+
+    all_tools = app_instance.list_tools()
+    logger.info(f"Available tools from app: {[getattr(t, '__name__', str(t)) for t in all_tools]}")
+
+    tool_manager.register_tools_from_app(app_instance)
+
+    all_registered = tool_manager.get_tools_by_app(app_name=app_instance.name)
+    logger.info(f"All registered tools: {[t.name for t in all_registered]}")
+
+    if test_case.tools:
+        tools = tool_manager.list_tools(
+            format=ToolFormat.LANGCHAIN, app_name=app_instance.name, tool_names=test_case.tools
+        )
+    else:
+        tools = tool_manager.list_tools(format=ToolFormat.LANGCHAIN, app_name=app_instance.name)
+
+    logger.info(f"Tools for test: {[tool.name for tool in tools]}")
+
+    azure_endpoint = os.environ.get("AZURE_OPENAI_ENDPOINT")
+    azure_api_key = os.environ.get("AZURE_OPENAI_API_KEY")
+    azure_deployment = os.environ.get("AZURE_OPENAI_DEPLOYMENT", "o4-mini")
+    api_version = os.environ.get("AZURE_OPENAI_API_VERSION", "2025-03-01-preview")
+
+    if not azure_endpoint or not azure_api_key:
+        raise ValueError(
+            "Azure OpenAI credentials not found. Please set AZURE_OPENAI_ENDPOINT and AZURE_OPENAI_API_KEY environment variables."
+        )
+
+    from langchain_openai import AzureChatOpenAI
+
+    llm = AzureChatOpenAI(
+        azure_endpoint=azure_endpoint,
+        azure_deployment=azure_deployment,
+        api_key=SecretStr(azure_api_key) if azure_api_key else None,
+        api_version=api_version,
+    )
+    logger.info(f"Using Azure OpenAI with deployment: {azure_deployment}")
+
+    agent = create_react_agent(
+        model=llm,
+        tools=tools,
+    )
+
+    messages = []
+    for task in test_case.tasks or []:
+        try:
+            messages.append(HumanMessage(content=task))
+            response = await agent.ainvoke({"messages": messages})
+            messages.append(AIMessage(content=response["messages"][-1].content))
+            logger.info(f"Task: {task}")
+            logger.info(f"Response: {response['messages'][-1].content}")
+            logger.info("---")
+        except Exception as e:
+            logger.error(f"Error: {e}")
+            import traceback
+
+            traceback.print_exc()
+            raise AssertionError(f"Task execution failed: {e}") from e
+
+    if test_case.validate_query:
+        messages.append(HumanMessage(content=test_case.validate_query))
+        structured_llm = llm.with_structured_output(ValidateResult)
+        result = await structured_llm.ainvoke(messages)
+        logger.info(f"Validation result: {result}")
+        assert result.success, f"Validation failed: {result.reasoning}"

universal_mcp-0.1.24rc3.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: universal-mcp
+Version: 0.1.24rc3
+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: 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: mkdocs-material>=9.6.15
+Requires-Dist: mkdocs>=1.6.1
+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: ty>=0.0.1a17
+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'
+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.24rc3.dist-info/RECORD

@@ -0,0 +1,70 @@
+universal_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/analytics.py,sha256=RzS88HSvJRGMjdJeLHnOgWzfKSb1jVnvOcD7NHqfERw,3733
+universal_mcp/cli.py,sha256=pPnIWLhSrLV9ukI8YAg2znehCR3VovhEkmh8XkRT3MU,2505
+universal_mcp/config.py,sha256=pkKs0gST65umzmNEvjHiOAtmiBaaICi45WG4Z0My0ak,11983
+universal_mcp/exceptions.py,sha256=Uen8UFgLHGlSwXgRUyF-nhqTwdiBuL3okgBVRV2AgtA,2150
+universal_mcp/logger.py,sha256=VmH_83efpErLEDTJqz55Dp0dioTXfGvMBLZUx5smOLc,2116
+universal_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/types.py,sha256=dVK7uSMuhvx5Xk6L7GGdjeaAIKiEwQskTmaVFwIS8LQ,176
+universal_mcp/agentr/__init__.py,sha256=ogOhH_OJwkoUZu_2nQJc7-vEGmYQxEjOE511-6ubrX0,217
+universal_mcp/agentr/agentr.py,sha256=JfawuREfXAyeNUE7o58DzTPhmQXuwsB_Da7c1Gf3Qxw,1059
+universal_mcp/agentr/client.py,sha256=oyF6VKq56UMVf5L1WnFTMSZ85W8Qcy-5HZ5XOGiIELM,4139
+universal_mcp/agentr/integration.py,sha256=V5GjqocqS02tRoI8MeV9PL6m-BzejwBzgJhOHo4MxAE,4212
+universal_mcp/agentr/registry.py,sha256=b9sr5JyT3HLj3e7GFpdXpT7ofGwLQc--y8k2DqF5dE0,3542
+universal_mcp/agentr/server.py,sha256=bIPmHMiKKwnUYnxmfZVRh1thcn7Rytm_-bNiXTfANzc,2098
+universal_mcp/agents/__init__.py,sha256=vgixOLTCcCmSweENV7GSAuOPyHXlE4XAbvOXyr4MrRA,185
+universal_mcp/agents/auto.py,sha256=o__71BCOHSfaj7Xt0PhsamVXdeP4o7irhtmu1q6-3Fo,25336
+universal_mcp/agents/base.py,sha256=U5JtpOopmUi73qcxtY9T2qJpYD7e6c62iVlIr3m5Chc,3430
+universal_mcp/agents/cli.py,sha256=7GdRBpu9rhZPiC2vaNQXWI7K-0yCnvdlmE0IFpvy2Gk,539
+universal_mcp/agents/hil.py,sha256=CTgX7CoFEyTFIaNaL-id2WALOPd0VBb79pHkQK8quM8,3671
+universal_mcp/agents/llm.py,sha256=YNxN43bVhGfdYs09yPkdkGCKJkj-2UNqkB1EFmtnUS4,309
+universal_mcp/agents/react.py,sha256=6L--LcuU5Ityi2UiZSYJWgp-lXGkxvpsx8mjvpoNRBQ,2021
+universal_mcp/agents/simple.py,sha256=UfmQIIff--_Y0DQ6oivRciHqSZvRqy_qwQn_UYVzYy8,1146
+universal_mcp/agents/utils.py,sha256=7kwFpD0Rv6JqHG-LlNCVwSu_xRX-N119mUmiBroHJL4,4109
+universal_mcp/agents/codeact/__init__.py,sha256=5D_I3lI_3tWjZERRoFav_bPe9UDaJ53pDzZYtyixg3E,10097
+universal_mcp/agents/codeact/sandbox.py,sha256=lGRzhuXTHCB1qauuOI3bH1-fPTsyL6Lf9EmMIz4C2xQ,1039
+universal_mcp/agents/codeact/test.py,sha256=bva-KkBNbGZn2f9nmmo9SNPQnY24Ni5gLHhJ5I0cm0k,481
+universal_mcp/agents/codeact/utils.py,sha256=VuMvLTxBBh3pgaJk8RWj5AK8XZFF-1gnZJ6jFLeM_CI,1690
+universal_mcp/applications/__init__.py,sha256=HrCnGdAT7w4puw2_VulBfjOLku9D5DuMaOwAuQzu6nI,2067
+universal_mcp/applications/application.py,sha256=pGF9Rb2D6qzlaSwlcfZ-dNqPtsLkQTqL3jpsRuJ6-qE,23835
+universal_mcp/applications/sample/app.py,sha256=E0JwaWD7qytwawb_iWc1pBnJ-Te7MMtab4MxOOebLdc,8972
+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/integrations/__init__.py,sha256=tfzLyPEPly5tfIcT8K6-oKCr_MEFGxOROHy_NeVy0KM,200
+universal_mcp/integrations/integration.py,sha256=H-hOoDHqk78A4Fi_TGN7OOFS7PDfqXK_nedH8iSz-6A,16459
+universal_mcp/servers/__init__.py,sha256=speBb_E94UJa4A6Fv8RHFeoJ7cR-q2bCMtKV7R21P5w,142
+universal_mcp/servers/server.py,sha256=qHeHm4UFVUr8TAailbEkWGq7EdlOASkOevY_0lyrWWs,5882
+universal_mcp/stores/__init__.py,sha256=quvuwhZnpiSLuojf0NfmBx2xpaCulv3fbKtKaSCEmuM,603
+universal_mcp/stores/store.py,sha256=yWbEGZb53z3fpVyqGWbes63z1CtIzC_IuM49OXy__UY,10137
+universal_mcp/tools/__init__.py,sha256=jC8hsqfTdtn32yU57AVFUXiU3ZmUOCfCERSCaNEIH7E,395
+universal_mcp/tools/adapters.py,sha256=YJ2oqgc8JgmtsdRRtvO-PO0Q0bKqTJ4Y3J6yxlESoTo,3947
+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=MajVskIptgXv1uZzwnSRycj1TSi7nhn4ebNSRkSSEDs,10455
+universal_mcp/tools/registry.py,sha256=XsmVZL1rY5XgIBPTmvKKBWFLAvB3d9LfYMb11b4wSPI,1169
+universal_mcp/tools/tools.py,sha256=1Q8bKiqj1E_-swvjmNHv16Orpd4p_HQtMKGxfqPmoPI,4570
+universal_mcp/utils/__init__.py,sha256=8wi4PGWu-SrFjNJ8U7fr2iFJ1ktqlDmSKj1xYd7KSDc,41
+universal_mcp/utils/common.py,sha256=3aJK3AnBkmYf-dbsFLaEu_dGuXQ0Qi2HuqYTueLVhXQ,10968
+universal_mcp/utils/installation.py,sha256=PU_GfHPqzkumKk-xG4L9CkBzSmABxmchwblZkx-zY-I,7204
+universal_mcp/utils/prompts.py,sha256=FJhqE0gPXDzYHS8gOjAVrdqVxc9X12ESnpd4C3jDSMI,27547
+universal_mcp/utils/singleton.py,sha256=RoOiKxBOAhp0TK1QaMDYi-8GjRcy2Vh-bAOuIAcYan0,775
+universal_mcp/utils/testing.py,sha256=J857Xt5K-hMxTc8UNJWlkzLbca1zObjwNhNXzYGxBHI,8009
+universal_mcp/utils/openapi/__inti__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/utils/openapi/api_generator.py,sha256=892AWoOCzzvFHVfSpEBg1m4LFRnWMmOSeY0DgLDW0fU,6960
+universal_mcp/utils/openapi/api_splitter.py,sha256=io7fV-E8hUIR4NxFlakqydbgrQF6aBAnZHPMlpxw-wc,20967
+universal_mcp/utils/openapi/cli.py,sha256=az5ObS74R-MmDCOZ1PHTJVKZJrHnsBOAweOUa7A-GqA,25918
+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=0Pn_ugkEwL0eMtctjc0XDMPZdB3SBOqza_J6BK8i_SY,62165
+universal_mcp/utils/openapi/postprocessor.py,sha256=NKvpXi73INRXxj1KOu8Ph3loWGICx2Uyy2Q8uOOqBoc,12177
+universal_mcp/utils/openapi/preprocessor.py,sha256=r4n0WQI__OzPL8FTza7jxiM4EYeZwa-3tvEJaJYZC44,63081
+universal_mcp/utils/openapi/readme.py,sha256=R2Jp7DUXYNsXPDV6eFTkLiy7MXbSULUj1vHh4O_nB4c,2974
+universal_mcp/utils/openapi/test_generator.py,sha256=h44gQXEXmrw4pD3-XNHKB7T9c2lDomqrJxVO6oszCqM,12186
+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.24rc3.dist-info/METADATA,sha256=rJ2CEZw0gwZkc3O39e1u_6VMcCr1dAhNBviG0YZXwto,3116
+universal_mcp-0.1.24rc3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp-0.1.24rc3.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
+universal_mcp-0.1.24rc3.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
+universal_mcp-0.1.24rc3.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.