universal-mcp 0.1.0__tar.gz → 0.1.1__tar.gz

{universal_mcp-0.1.0 → universal_mcp-0.1.1}/.gitignore

@@ -14,4 +14,12 @@ wheels/
 .env.local
 
 
-dump/
+dump/
+
+
+# SQLite database
+*.db
+*.sqlite
+*.sqlite3
+*.db-shm
+*.db-wal

universal_mcp-0.1.1/CONTRIBUTING.md

@@ -0,0 +1,78 @@
+# Contributing to AgentR
+
+Thank you for your interest in contributing to AgentR! This document provides guidelines and instructions for contributing to the project.
+
+## 🚀 Getting Started
+
+1. Fork the repository at git@github.com:AgentrDev/universal-mcp.git
+2. Clone your fork
+3. Create a new branch for your changes:
+   ```bash
+   git checkout -b feature/your-feature-name
+   ```
+
+4. Install development dependencies:
+   ```bash
+   pip install -e ".[test]"
+   ```
+
+5. Make your changes and ensure tests pass:
+   ```bash
+   pytest
+   ```
+
+6. Commit your changes following conventional commits:
+   ```bash
+   git commit -m "feat: add new feature"
+   ```
+
+7. Push to your fork:
+   ```bash
+   git push origin feature/your-feature-name
+   ```
+
+8. Open a Pull Request against the main repository
+
+## 📝 Guidelines
+
+### Code Style
+- Follow PEP 8 guidelines
+- Use type hints where possible
+- Include docstrings for functions and classes
+- Keep functions focused and single-purpose
+
+### Testing
+- Add tests for new features
+- Ensure all tests pass before submitting PR
+- Maintain or improve code coverage
+
+### Pull Requests
+- Keep PRs focused on a single change
+- Include a clear description of changes
+- Reference any related issues
+- Update documentation as needed
+
+### Commit Messages
+Follow conventional commits format:
+- feat: New feature
+- fix: Bug fix
+- docs: Documentation changes
+- style: Code style changes
+- refactor: Code refactoring
+- test: Test updates
+- chore: Maintenance tasks
+
+## 🐛 Reporting Issues
+
+- Search existing issues before creating new ones
+- Include clear steps to reproduce
+- Provide system information
+- Add relevant logs or screenshots
+
+## 📚 Documentation
+
+- Keep README.md updated
+- Document new features
+- Include docstrings
+- Update CHANGELOG.md for significant changes
+

{universal_mcp-0.1.0 → universal_mcp-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.0
+Version: 0.1.1
 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
@@ -10,6 +10,13 @@ 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: playground
+Requires-Dist: fastapi[standard]>=0.115.12; extra == 'playground'
+Requires-Dist: langchain-anthropic>=0.3.10; extra == 'playground'
+Requires-Dist: langchain-mcp-adapters>=0.0.3; extra == 'playground'
+Requires-Dist: langgraph-checkpoint-sqlite>=2.0.6; extra == 'playground'
+Requires-Dist: langgraph>=0.3.24; extra == 'playground'
+Requires-Dist: streamlit>=1.44.1; extra == 'playground'
 Provides-Extra: test
 Requires-Dist: pytest-asyncio>=0.26.0; extra == 'test'
 Requires-Dist: pytest>=8.3.5; extra == 'test'
@@ -87,6 +94,24 @@ if __name__ == "__main__":
     server.run()
 ```
 
+## Using Playground
+
+Start MCP Server
+```bash
+universal_mcp run -t sse
+```
+
+Start FastAPI app
+```bash
+fastapi run src/playground
+```
+
+Start Frontend
+```bash
+streamlit run src/playground/streamlit.py
+```
+
+
 ## 🧩 Available Applications
 AgentR comes with several pre-built applications:
 

{universal_mcp-0.1.0 → universal_mcp-0.1.1}/README.md

@@ -70,6 +70,24 @@ if __name__ == "__main__":
     server.run()
 ```
 
+## Using Playground
+
+Start MCP Server
+```bash
+universal_mcp run -t sse
+```
+
+Start FastAPI app
+```bash
+fastapi run src/playground
+```
+
+Start Frontend
+```bash
+streamlit run src/playground/streamlit.py
+```
+
+
 ## 🧩 Available Applications
 AgentR comes with several pre-built applications:
 

{universal_mcp-0.1.0 → universal_mcp-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "universal-mcp"
-version = "0.1.0"
+version = "0.1.1"
 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 = [
@@ -21,11 +21,17 @@ test = [
   "pytest>=8.3.5",
   "pytest-asyncio>=0.26.0",
 ]
-
+playground = [
+    "fastapi[standard]>=0.115.12",
+    "langchain-anthropic>=0.3.10",
+    "langchain-mcp-adapters>=0.0.3",
+    "langgraph>=0.3.24",
+    "langgraph-checkpoint-sqlite>=2.0.6",
+    "streamlit>=1.44.1",
+]
 [project.scripts]
 universal_mcp = "universal_mcp.cli:app"
 
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
-

universal_mcp-0.1.1/src/playground/__init__.py

@@ -0,0 +1,3 @@
+from playground.service import app
+
+__all__ = ["app"]

universal_mcp-0.1.1/src/playground/agents/react.py

@@ -0,0 +1,50 @@
+from contextlib import asynccontextmanager
+from langchain_anthropic import ChatAnthropic
+from langgraph.prebuilt import create_react_agent
+from langchain_core.messages import HumanMessage
+import asyncio
+from langchain_mcp_adapters.client import MultiServerMCPClient
+
+
+@asynccontextmanager
+async def load_tools():
+    async with MultiServerMCPClient(
+        {
+            "agentr": {
+                "url": "http://localhost:8005/sse",
+                "transport": "sse",
+            },
+        }
+    ) as client:
+        tools = client.get_tools()
+        yield tools
+
+
+@asynccontextmanager
+async def create_agent():
+    llm = ChatAnthropic(model="claude-3-5-sonnet-latest")
+    async with load_tools() as tools:
+        yield create_react_agent(
+            model=llm,
+            tools=tools,
+            debug=False,
+        )
+
+
+async def main():
+    async with create_agent() as agent:
+        print("Welcome to the agent!")
+        messages = []
+        while True:
+            human_input = input("Enter your message: ")
+            if human_input.lower() in ["exit", "quit", "q"]:
+                break
+            messages.append(HumanMessage(content=human_input))
+            results = await agent.ainvoke({"messages": messages})
+            ai_message = results["messages"][-1]
+            messages.append(ai_message)
+            print(ai_message.content)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

universal_mcp-0.1.1/src/playground/client.py

@@ -0,0 +1,288 @@
+import json
+import os
+from collections.abc import AsyncGenerator, Generator
+from typing import Any
+
+import httpx
+
+from playground.schema import (
+    ChatHistory,
+    ChatHistoryInput,
+    ChatMessage,
+    StreamInput,
+    UserInput,
+)
+
+
+class AgentClientError(Exception):
+    pass
+
+
+class AgentClient:
+    """Client for interacting with the agent service."""
+
+    def __init__(
+        self,
+        base_url: str = "http://0.0.0.0",
+        timeout: float | None = None,
+    ) -> None:
+        """
+        Initialize the client.
+
+        Args:
+            base_url (str): The base URL of the agent service.
+            agent (str): The name of the default agent to use.
+            timeout (float, optional): The timeout for requests.
+            get_info (bool, optional): Whether to fetch agent information on init.
+                Default: True
+        """
+        self.base_url = base_url
+        self.auth_secret = os.getenv("AUTH_SECRET")
+        self.timeout = timeout
+
+    @property
+    def _headers(self) -> dict[str, str]:
+        headers = {}
+        if self.auth_secret:
+            headers["Authorization"] = f"Bearer {self.auth_secret}"
+        return headers
+
+    def retrieve_info(self) -> None:
+        try:
+            response = httpx.get(
+                f"{self.base_url}/info",
+                headers=self._headers,
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+        except httpx.HTTPError as e:
+            raise AgentClientError(f"Error getting service info: {e}")
+
+    async def ainvoke(
+        self,
+        message: str,
+        model: str | None = None,
+        thread_id: str | None = None,
+        agent_config: dict[str, Any] | None = None,
+    ) -> ChatMessage:
+        """
+        Invoke the agent asynchronously. Only the final message is returned.
+
+        Args:
+            message (str): The message to send to the agent
+            model (str, optional): LLM model to use for the agent
+            thread_id (str, optional): Thread ID for continuing a conversation
+            agent_config (dict[str, Any], optional): Additional configuration to pass through to the agent
+
+        Returns:
+            AnyMessage: The response from the agent
+        """
+        request = UserInput(message=message)
+        if thread_id:
+            request.thread_id = thread_id
+        if agent_config:
+            request.agent_config = agent_config
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    f"{self.base_url}/invoke",
+                    json=request.model_dump(),
+                    headers=self._headers,
+                    timeout=self.timeout,
+                )
+                response.raise_for_status()
+            except httpx.HTTPError as e:
+                raise AgentClientError(f"Error: {e}")
+
+        return ChatMessage.model_validate(response.json())
+
+    def invoke(
+        self,
+        message: str,
+        model: str | None = None,
+        thread_id: str | None = None,
+        agent_config: dict[str, Any] | None = None,
+    ) -> ChatMessage:
+        """
+        Invoke the agent synchronously. Only the final message is returned.
+
+        Args:
+            message (str): The message to send to the agent
+            model (str, optional): LLM model to use for the agent
+            thread_id (str, optional): Thread ID for continuing a conversation
+            agent_config (dict[str, Any], optional): Additional configuration to pass through to the agent
+
+        Returns:
+            ChatMessage: The response from the agent
+        """
+        request = UserInput(message=message)
+        if thread_id:
+            request.thread_id = thread_id
+        if model:
+            request.model = model
+        if agent_config:
+            request.agent_config = agent_config
+        try:
+            response = httpx.post(
+                f"{self.base_url}/invoke",
+                json=request.model_dump(),
+                headers=self._headers,
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+        except httpx.HTTPError as e:
+            raise AgentClientError(f"Error: {e}")
+
+        return ChatMessage.model_validate(response.json())
+
+    def _parse_stream_line(self, line: str) -> ChatMessage | str | None:
+        line = line.strip()
+        if line.startswith("data: "):
+            data = line[6:]
+            if data == "[DONE]":
+                return None
+            try:
+                parsed = json.loads(data)
+            except Exception as e:
+                raise Exception(f"Error JSON parsing message from server: {e}")
+            match parsed["type"]:
+                case "message":
+                    # Convert the JSON formatted message to an AnyMessage
+                    try:
+                        return ChatMessage.model_validate(parsed["content"])
+                    except Exception as e:
+                        raise Exception(f"Server returned invalid message: {e}")
+                case "token":
+                    # Yield the str token directly
+                    return parsed["content"]
+                case "error":
+                    raise Exception(parsed["content"])
+        return None
+
+    def stream(
+        self,
+        message: str,
+        model: str | None = None,
+        thread_id: str | None = None,
+        agent_config: dict[str, Any] | None = None,
+        stream_tokens: bool = True,
+    ) -> Generator[ChatMessage | str, None, None]:
+        """
+        Stream the agent's response synchronously.
+
+        Each intermediate message of the agent process is yielded as a ChatMessage.
+        If stream_tokens is True (the default value), the response will also yield
+        content tokens from streaming models as they are generated.
+
+        Args:
+            message (str): The message to send to the agent
+            model (str, optional): LLM model to use for the agent
+            thread_id (str, optional): Thread ID for continuing a conversation
+            agent_config (dict[str, Any], optional): Additional configuration to pass through to the agent
+            stream_tokens (bool, optional): Stream tokens as they are generated
+                Default: True
+
+        Returns:
+            Generator[ChatMessage | str, None, None]: The response from the agent
+        """
+        request = StreamInput(message=message, stream_tokens=stream_tokens)
+        if thread_id:
+            request.thread_id = thread_id
+        if model:
+            request.model = model
+        if agent_config:
+            request.agent_config = agent_config
+        try:
+            with httpx.stream(
+                "POST",
+                f"{self.base_url}/stream",
+                json=request.model_dump(),
+                headers=self._headers,
+                timeout=self.timeout,
+            ) as response:
+                response.raise_for_status()
+                for line in response.iter_lines():
+                    if line.strip():
+                        parsed = self._parse_stream_line(line)
+                        if parsed is None:
+                            break
+                        yield parsed
+        except httpx.HTTPError as e:
+            raise AgentClientError(f"Error: {e}")
+
+    async def astream(
+        self,
+        message: str,
+        model: str | None = None,
+        thread_id: str | None = None,
+        agent_config: dict[str, Any] | None = None,
+        stream_tokens: bool = True,
+    ) -> AsyncGenerator[ChatMessage | str, None]:
+        """
+        Stream the agent's response asynchronously.
+
+        Each intermediate message of the agent process is yielded as an AnyMessage.
+        If stream_tokens is True (the default value), the response will also yield
+        content tokens from streaming modelsas they are generated.
+
+        Args:
+            message (str): The message to send to the agent
+            model (str, optional): LLM model to use for the agent
+            thread_id (str, optional): Thread ID for continuing a conversation
+            agent_config (dict[str, Any], optional): Additional configuration to pass through to the agent
+            stream_tokens (bool, optional): Stream tokens as they are generated
+                Default: True
+
+        Returns:
+            AsyncGenerator[ChatMessage | str, None]: The response from the agent
+        """
+
+        request = StreamInput(message=message, stream_tokens=stream_tokens)
+        if thread_id:
+            request.thread_id = thread_id
+        if model:
+            request.model = model
+        if agent_config:
+            request.agent_config = agent_config
+        async with httpx.AsyncClient() as client:
+            try:
+                async with client.stream(
+                    "POST",
+                    f"{self.base_url}/stream",
+                    json=request.model_dump(),
+                    headers=self._headers,
+                    timeout=self.timeout,
+                ) as response:
+                    response.raise_for_status()
+                    async for line in response.aiter_lines():
+                        if line.strip():
+                            parsed = self._parse_stream_line(line)
+                            if parsed is None:
+                                break
+                            yield parsed
+            except httpx.HTTPError as e:
+                raise AgentClientError(f"Error: {e}")
+
+    def get_history(
+        self,
+        thread_id: str,
+    ) -> ChatHistory:
+        """
+        Get chat history.
+
+        Args:
+            thread_id (str, optional): Thread ID for identifying a conversation
+        """
+        request = ChatHistoryInput(thread_id=thread_id)
+        try:
+            response = httpx.post(
+                f"{self.base_url}/history",
+                json=request.model_dump(),
+                headers=self._headers,
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+        except httpx.HTTPError as e:
+            raise AgentClientError(f"Error: {e}")
+
+        return ChatHistory.model_validate(response.json())

universal_mcp-0.1.1/src/playground/memory/__init__.py

@@ -0,0 +1,14 @@
+from langgraph.checkpoint.base import BaseCheckpointSaver
+
+from playground.memory.sqlite import get_sqlite_saver
+
+
+def initialize_database() -> BaseCheckpointSaver:
+    """
+    Initialize the appropriate database checkpointer based on configuration.
+    Returns an initialized AsyncCheckpointer instance.
+    """
+    return get_sqlite_saver()
+
+
+__all__ = ["initialize_database"]

universal_mcp-0.1.1/src/playground/memory/sqlite.py

@@ -0,0 +1,9 @@
+from langgraph.checkpoint.base import BaseCheckpointSaver
+from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
+
+from playground.settings import settings
+
+
+def get_sqlite_saver() -> BaseCheckpointSaver:
+    """Initialize and return a SQLite saver instance."""
+    return AsyncSqliteSaver.from_conn_string(settings.SQLITE_DB_PATH)