universal-mcp 0.1.24rc13__py3-none-any.whl → 0.1.24rc17__py3-none-any.whl

universal_mcp/agents/react.py

@@ -1,84 +0,0 @@
-from langgraph.checkpoint.base import BaseCheckpointSaver
-from langgraph.prebuilt import create_react_agent
-from loguru import logger
-
-from universal_mcp.agentr.registry import AgentrRegistry
-from universal_mcp.agents.base import BaseAgent
-from universal_mcp.agents.llm import load_chat_model
-from universal_mcp.agents.tools import load_mcp_tools
-from universal_mcp.tools.registry import ToolRegistry
-from universal_mcp.types import ToolConfig, ToolFormat
-
-
-class ReactAgent(BaseAgent):
-    def __init__(
-        self,
-        name: str,
-        instructions: str,
-        model: str,
-        memory: BaseCheckpointSaver | None = None,
-        tools: ToolConfig | None = None,
-        registry: ToolRegistry | None = None,
-        max_iterations: int = 10,
-        **kwargs,
-    ):
-        super().__init__(name, instructions, model, memory, **kwargs)
-        self.llm = load_chat_model(model)
-        self.tools = tools
-        self.max_iterations = max_iterations
-        self.registry = registry
-
-    async def _build_graph(self):
-        if self.tools:
-            config = self.tools.model_dump(exclude_none=True)
-            if config.get("agentrServers") and not self.registry:
-                raise ValueError("Agentr servers are configured but no registry is provided")
-            agentr_tools = (
-                await self.registry.export_tools(self.tools, ToolFormat.LANGCHAIN)
-                if config.get("agentrServers")
-                else []
-            )
-            logger.debug(agentr_tools)
-            mcp_tools = await load_mcp_tools(config["mcpServers"]) if config.get("mcpServers") else []
-            logger.debug(mcp_tools)
-            tools = agentr_tools + mcp_tools
-        else:
-            tools = []
-        logger.debug(f"Initialized ReactAgent: name={self.name}, model={self.model}")
-        return create_react_agent(
-            self.llm,
-            tools,
-            prompt=self._build_system_message(),
-            checkpointer=self.memory,
-        )
-
-    def _build_system_message(self) -> str:
-        system_message = f"""You are {self.name}.
-
-You have access to various tools that can help you answer questions and complete tasks. When you need to use a tool:
-
-1. Think about what information you need
-2. Call the appropriate tool with the right parameters
-3. Use the tool results to provide a comprehensive answer
-
-Always explain your reasoning and be thorough in your responses. If you need to use multiple tools to answer a question completely, do so.
-
-{self.instructions}
-"""
-        return system_message
-
-
-if __name__ == "__main__":
-    import asyncio
-
-    agent = ReactAgent(
-        "Universal React Agent",
-        instructions="",
-        model="azure/gpt-4o",
-        tools=ToolConfig(agentrServers={"google-mail": {"tools": ["send_email"]}}),
-        registry=AgentrRegistry(),
-    )
-    result = asyncio.run(
-        agent.invoke(user_input="Send an email with the subject 'testing react agent' to manoj@agentr.dev")
-    )
-    logger.info(result["messages"][-1].content)

universal_mcp/agents/shared/agent_node.py

@@ -1,34 +0,0 @@
-from pydantic import BaseModel, Field
-
-
-class Agent(BaseModel):
-    name: str = Field(description="The name of the agent")
-    description: str = Field(description="A small paragraph description of the agent")
-    expertise: str = Field(description="Agents expertise. Growth expert, SEO expert, etc")
-    instructions: str = Field(description="The instructions for the agent")
-    schedule: str = Field(
-        description="The schedule for the agent in crontab syntax (e.g., '0 9 * * *' for daily at 9 AM)"
-    )
-
-
-AGENT_PROMPT = """You are an AI assistant that creates autonomous agents based on user requests.
-
-Your task is to analyze the user's request and create a structured agent definition that includes:
-- A clear name for the agent
-- A concise description of what the agent does
-- The agent's area of expertise
-- Detailed instructions for executing the task
-- A cron schedule for when the agent should run
-- A list of apps/services the agent will need to use
-
-Be specific and actionable in your agent definitions. Consider the user's intent and create agents that can effectively accomplish their goals.
-
-<query>
-{query}
-</query>
-"""
-
-
-async def generate_agent(llm, query):
-    response = await llm.with_structured_output(Agent).ainvoke(input=AGENT_PROMPT.format(query=query))
-    return response

universal_mcp/agents/shared/tool_node.py

@@ -1,235 +0,0 @@
-# tool_node.py
-
-import asyncio
-from typing import Annotated, TypedDict
-
-from langchain_core.language_models import BaseChatModel
-from langchain_core.messages import AIMessage, AnyMessage, HumanMessage
-from langgraph.graph import END, StateGraph
-from langgraph.graph.message import add_messages
-from loguru import logger
-from pydantic import BaseModel, Field
-
-from universal_mcp.tools.registry import ToolRegistry
-from universal_mcp.types import AgentrConnection, AgentrToolConfig
-
-# --- LangGraph Agent ---
-
-
-class AgentState(TypedDict):
-    task: str
-    apps_required: bool
-    relevant_apps: list[str]
-    apps_with_tools: AgentrToolConfig
-    messages: Annotated[list[AnyMessage], add_messages]
-    reasoning: str
-
-
-class ToolSelectionOutput(BaseModel):
-    tool_ids: list[str] = Field(description="The ids of the tools to use")
-
-
-def build_tool_node_graph(llm: BaseChatModel, registry: ToolRegistry) -> StateGraph:
-    """Builds the LangGraph workflow."""
-
-    async def _check_if_app_needed(state: AgentState) -> AgentState:
-        """Checks if an external application is needed for the given task."""
-        task = state["task"]
-        prompt = f"""
-            Given the user's task: "{task}"
-            Does this task require an external application to be completed?
-            Your answer should be a simple "Yes" or "No", followed by a brief explanation.
-            For example:
-            Yes, an external application is needed to send emails.
-            No, this is a general question that can be answered directly.
-            """
-        response = await llm.ainvoke(prompt)
-        content = response.content.strip()
-        reasoning = f"Initial check for app requirement. LLM response: {content}"
-
-        if content.lower().startswith("yes"):
-            return {
-                **state,
-                "messages": [AIMessage(content=content)],
-                "apps_required": True,
-                "reasoning": reasoning,
-            }
-        else:
-            return {
-                **state,
-                "messages": [AIMessage(content=content)],
-                "apps_required": False,
-                "reasoning": reasoning,
-            }
-
-    async def _find_relevant_apps(state: AgentState) -> AgentState:
-        """Identifies relevant apps for the given task, preferring connected apps."""
-        task = state["task"]
-        all_apps = await registry.list_all_apps()
-        connected_apps = await registry.list_connected_apps()
-        prompt = """
-You are an expert at identifying which applications are needed to complete specific tasks.
-
-TASK: "{task}"
-
-AVAILABLE APPS:
-{all_apps}
-
-CONNECTED APPS (user has already authenticated these):
-{connected_apps}
-
-INSTRUCTIONS:
-1. Analyze the task carefully to understand what functionality is required.
-2. Review the available apps and their descriptions to identify which ones could help.
-3. If multiple apps can perform the task, prefer connected apps, but you MUST include all relevant apps.
-4. Consider apps that provide complementary functionality for complex tasks.
-5. Only suggest apps that are directly relevant to the core task requirements.
-6. Your output should be a list of app IDs.
-
-"""
-
-        class AppList(BaseModel):
-            app_list: list[str]
-            reasoning: str
-
-        response = await llm.with_structured_output(AppList).ainvoke(
-            input=prompt.format(task=task, all_apps=all_apps, connected_apps=connected_apps)
-        )
-        app_list = response.app_list
-        reasoning = f"Found relevant apps: {app_list}. Reasoning: {response.reasoning}"
-        logger.info(f"Found relevant apps: {app_list}.")
-
-        return {
-            **state,
-            "messages": [AIMessage(content=f"Identified relevant apps: {', '.join(app_list)}")],
-            "relevant_apps": app_list,
-            "reasoning": state.get("reasoning", "") + "\n" + reasoning,
-        }
-
-    async def _select_tools(task: str, tools: list[dict]) -> list[str]:
-        """Selects the most appropriate tools from a list for a given task."""
-        tool_candidates = [f"{tool['name']}: {tool['description']}" for tool in tools]
-
-        SELECT_TOOL_PROMPT = f"""You are an AI assistant that helps the user perform tasks using various apps (each app has multiple tools).
-You will be provided with a task and a list of tools which might be relevant for this task.
-
-Your goal is to select the most appropriate tool for the given task.
-<task>
-{task}
-</task>
-
-<tool_candidates>
- - {tool_candidates}
-</tool_candidates>
-
-Only return tool ids.
-"""
-
-        response = await llm.with_structured_output(schema=ToolSelectionOutput).ainvoke(input=SELECT_TOOL_PROMPT)
-
-        selected_tool_ids = response.tool_ids
-        return selected_tool_ids
-
-    async def _generate_search_query(task: str) -> str:
-        """Generates a concise search query from the user's task."""
-        prompt = f"""
-You are an expert at summarizing a user's task into a concise search query for finding relevant tools.
-The query should capture all the main actions or intents of the task.
-
-For example:
-Task: "Send an email to abc@the-read-example.com with the subject 'Hello'"
-Query: "send email"
-
-Task: "Create a new contact in my CRM for John Doe"
-Query: "create contact"
-
-Task: "Find the latest news about artificial intelligence"
-Query: "search news"
-
-Task: "Post a message to the #general channel in Slack and create a new issue in Jira"
-Query: "send message, create issue"
-
-Task: "{task}"
-"""
-
-        class SearchQuery(BaseModel):
-            query: str
-
-        response = await llm.with_structured_output(SearchQuery).ainvoke(input=prompt.format(task=task))
-        query = response.query
-        logger.info(f"Generated search query '{query}' for task '{task}'")
-        return query
-
-    async def _search_tools(state: AgentState) -> AgentState:
-        """Searches for and filters tools in the relevant apps."""
-        task = state["task"]
-        logger.info(f"Searching for tools in relevant apps for task: {task}")
-        search_query = await _generate_search_query(task)
-        apps_with_tools_dict = {}
-        reasoning_steps = []
-        for app_name in state["relevant_apps"]:
-            logger.info(f"Searching for tools in {app_name} for task: {task} with query '{search_query}'")
-            found_tools = await registry.search_tools(query=search_query, app_id=app_name)
-            selected_tools = await _select_tools(task, found_tools)
-            apps_with_tools_dict[app_name] = selected_tools
-            reasoning_steps.append(f"For '{app_name}', selected tool(s): {', '.join(selected_tools)}.")
-
-        agentr_servers = {app_name: AgentrConnection(tools=tools) for app_name, tools in apps_with_tools_dict.items()}
-        tool_config = AgentrToolConfig(agentrServers=agentr_servers)
-
-        return {
-            **state,
-            "apps_with_tools": tool_config,
-            "reasoning": state.get("reasoning", "") + "\n" + "\n".join(reasoning_steps),
-        }
-
-    def _handle_no_apps_found(state: AgentState) -> AgentState:
-        """Handles the case where no relevant apps are found."""
-        reasoning = "No suitable application was found among the available apps."
-        return {
-            **state,
-            "apps_with_tools": AgentrToolConfig(agentrServers={}),
-            "reasoning": state.get("reasoning", "") + "\n" + reasoning,
-        }
-
-    workflow = StateGraph(AgentState)
-
-    workflow.add_node("check_if_app_needed", _check_if_app_needed)
-    workflow.add_node("find_relevant_apps", _find_relevant_apps)
-    workflow.add_node("search_tools", _search_tools)
-    workflow.add_node("handle_no_apps_found", _handle_no_apps_found)
-
-    workflow.set_entry_point("check_if_app_needed")
-
-    workflow.add_conditional_edges(
-        "check_if_app_needed",
-        lambda state: "find_relevant_apps" if state["apps_required"] else END,
-    )
-    workflow.add_conditional_edges(
-        "find_relevant_apps",
-        lambda state: "search_tools" if state["relevant_apps"] else "handle_no_apps_found",
-    )
-
-    workflow.add_edge("search_tools", END)
-    workflow.add_edge("handle_no_apps_found", END)
-
-    return workflow.compile()
-
-
-async def main():
-    from universal_mcp.agentr.registry import AgentrRegistry
-    from universal_mcp.agents.llm import load_chat_model
-
-    registry = AgentrRegistry()
-    llm = load_chat_model("gemini/gemini-2.5-flash")
-    graph = build_tool_node_graph(llm, registry)
-    initial_state = {
-        "task": "Send an email to manoj@agentr.dev",
-        "messages": [HumanMessage(content="Send an email to manoj@agentr.dev")],
-    }
-    result = await graph.ainvoke(initial_state)
-    print(result)
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

universal_mcp/agents/simple.py

@@ -1,40 +0,0 @@
-import asyncio
-from typing import Annotated
-
-from langgraph.checkpoint.base import BaseCheckpointSaver
-from langgraph.graph import END, START, StateGraph
-from langgraph.graph.message import add_messages
-from typing_extensions import TypedDict
-
-from universal_mcp.agents.base import BaseAgent
-from universal_mcp.agents.llm import load_chat_model
-
-
-class State(TypedDict):
-    messages: Annotated[list, add_messages]
-
-
-class SimpleAgent(BaseAgent):
-    def __init__(self, name: str, instructions: str, model: str, memory: BaseCheckpointSaver = None, **kwargs):
-        super().__init__(name, instructions, model, memory, **kwargs)
-        self.llm = load_chat_model(model)
-
-    async def _build_graph(self):
-        graph_builder = StateGraph(State)
-
-        async def chatbot(state: State):
-            messages = [
-                {"role": "system", "content": self.instructions},
-                *state["messages"],
-            ]
-            return {"messages": [await self.llm.ainvoke(messages)]}
-
-        graph_builder.add_node("chatbot", chatbot)
-        graph_builder.add_edge(START, "chatbot")
-        graph_builder.add_edge("chatbot", END)
-        return graph_builder.compile(checkpointer=self.memory)
-
-
-if __name__ == "__main__":
-    agent = SimpleAgent("Simple Agent", "You are a helpful assistant", "azure/gpt-4o")
-    asyncio.run(agent.run_interactive())

universal_mcp/agents/tools.py

@@ -1,35 +0,0 @@
-import json
-
-from langchain_mcp_adapters.client import MultiServerMCPClient
-
-from universal_mcp.agentr.integration import AgentrIntegration
-from universal_mcp.applications import app_from_slug
-from universal_mcp.tools.adapters import ToolFormat
-from universal_mcp.tools.manager import ToolManager
-from universal_mcp.types import ToolConfig
-
-
-async def load_agentr_tools(agentr_servers: dict):
-    tool_manager = ToolManager()
-    for app_name, tool_names in agentr_servers.items():
-        app = app_from_slug(app_name)
-        integration = AgentrIntegration(name=app_name)
-        app_instance = app(integration=integration)
-        tool_manager.register_tools_from_app(app_instance, tool_names=tool_names["tools"])
-    tools = tool_manager.list_tools(format=ToolFormat.LANGCHAIN)
-    return tools
-
-
-async def load_mcp_tools(mcp_servers: dict):
-    client = MultiServerMCPClient(mcp_servers)
-    tools = await client.get_tools()
-    return tools
-
-
-async def load_tools(path: str) -> ToolConfig:
-    with open(path) as f:
-        data = json.load(f)
-        config = ToolConfig.model_validate(data)
-        agentr_tools = await load_agentr_tools(config.model_dump(exclude_none=True)["agentrServers"])
-        mcp_tools = await load_mcp_tools(config.model_dump(exclude_none=True)["mcpServers"])
-        return agentr_tools + mcp_tools

universal_mcp/agents/utils.py

@@ -1,111 +0,0 @@
-import json
-from contextlib import contextmanager
-
-from rich.console import Console
-from rich.live import Live
-from rich.markdown import Markdown
-from rich.panel import Panel
-from rich.prompt import Prompt
-from rich.table import Table
-
-
-class RichCLI:
-    def __init__(self):
-        self.console = Console()
-
-    def display_welcome(self, agent_name: str):
-        """Display welcome message"""
-        welcome_text = f"""
-# Welcome to {agent_name}!
-
-Available commands:
-- Type your questions naturally
-- `/help` - Show help
-- `/tools` - List available tools
-- `/exit` - Exit the application
-        """
-        self.console.print(Panel(Markdown(welcome_text), title="🤖 AI Agent CLI", border_style="blue"))
-
-    def display_agent_response(self, response: str, agent_name: str):
-        """Display agent response with formatting"""
-        self.console.print(Panel(Markdown(response), title=f"🤖 {agent_name}", border_style="green", padding=(1, 2)))
-
-    @contextmanager
-    def display_agent_response_streaming(self, agent_name: str):
-        """Context manager for streaming agent response updates."""
-
-        with Live(refresh_per_second=10, console=self.console) as live:
-
-            class StreamUpdater:
-                content = []
-
-                def update(self, chunk: str):
-                    self.content.append(chunk)
-                    panel = Panel(
-                        Markdown("".join(self.content)),
-                        title=f"🤖 {agent_name}",
-                        border_style="green",
-                        padding=(1, 2),
-                    )
-                    live.update(panel)
-
-            yield StreamUpdater()
-
-    def display_thinking(self, thought: str):
-        """Display agent's thinking process"""
-        if thought:
-            self.console.print(Panel(thought, title="💭 Thinking", border_style="yellow", padding=(1, 2)))
-
-    def display_tools(self, tools: list):
-        """Display available tools in a table"""
-        table = Table(title="🛠️ Available Tools")
-        table.add_column("Tool Name", style="cyan")
-        table.add_column("Description", style="white")
-
-        for tool in tools:
-            func_info = tool["function"]
-            table.add_row(func_info["name"], func_info["description"])
-
-        self.console.print(table)
-
-    def display_tool_call(self, tool_call: dict):
-        """Display tool call"""
-        tool_call_str = json.dumps(tool_call, indent=2)
-        self.console.print(Panel(tool_call_str, title="🛠️ Tool Call", border_style="green", padding=(1, 2)))
-
-    def display_tool_result(self, tool_result: dict):
-        """Display tool result"""
-        tool_result_str = json.dumps(tool_result, indent=2)
-        self.console.print(Panel(tool_result_str, title="🛠️ Tool Result", border_style="green", padding=(1, 2)))
-
-    def display_error(self, error: str):
-        """Display error message"""
-        self.console.print(Panel(error, title="❌ Error", border_style="red"))
-
-    def get_user_input(self) -> str:
-        """Get user input with rich prompt"""
-        return Prompt.ask("[bold blue]You[/bold blue]", console=self.console)
-
-    def display_info(self, message: str):
-        """Display info message"""
-        self.console.print(f"[bold cyan]ℹ️ {message}[/bold cyan]")
-
-    def clear_screen(self):
-        """Clear the screen"""
-        self.console.clear()
-
-    def handle_interrupt(self, interrupt) -> str | bool:
-        interrupt_type = interrupt.value["type"]
-        if interrupt_type == "text":
-            value = Prompt.ask(interrupt.value["question"])
-            return value
-        elif interrupt_type == "bool":
-            value = Prompt.ask(interrupt.value["question"], choices=["y", "n"], default="y")
-            return value
-        elif interrupt_type == "choice":
-            value = Prompt.ask(
-                interrupt.value["question"], choices=interrupt.value["choices"], default=interrupt.value["choices"][0]
-            )
-            return value
-        else:
-            raise ValueError(f"Invalid interrupt type: {interrupt.value['type']}")

universal_mcp/analytics.py

@@ -1,111 +0,0 @@
-import os
-import uuid
-from functools import lru_cache
-from importlib.metadata import version
-
-import posthog
-from loguru import logger
-
-
-class Analytics:
-    """A singleton class for tracking analytics events using PostHog.
-
-    This class handles the initialization of the PostHog client and provides
-    methods to track key events such as application loading and tool execution.
-    Telemetry can be disabled by setting the TELEMETRY_DISABLED environment
-    variable to "true".
-    """
-
-    _instance = None
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            cls._instance._initialize()
-        return cls._instance
-
-    def _initialize(self):
-        """Initializes the PostHog client and sets up analytics properties.
-
-        This internal method configures the PostHog API key and host.
-        It also determines if analytics should be enabled based on the
-        TELEMETRY_DISABLED environment variable and generates a unique
-        user ID.
-        """
-        posthog.host = "https://us.i.posthog.com"
-        posthog.api_key = "phc_6HXMDi8CjfIW0l04l34L7IDkpCDeOVz9cOz1KLAHXh8"
-        self.enabled = os.getenv("TELEMETRY_DISABLED", "false").lower() != "true"
-        self.user_id = str(uuid.uuid4())[:8]
-
-    @staticmethod
-    @lru_cache(maxsize=1)
-    def get_version():
-        """Retrieves the installed version of the universal_mcp package.
-
-        Uses importlib.metadata to get the package version.
-        Caches the result for efficiency.
-
-        Returns:
-            str: The package version string, or "unknown" if not found.
-        """
-        try:
-            return version("universal_mcp")
-        except ImportError:  # Should be PackageNotFoundError, but matching existing code
-            return "unknown"
-
-    def track_app_loaded(self, app_name: str):
-        """Tracks an event when an application is successfully loaded.
-
-        This event helps understand which applications are being utilized.
-
-        Args:
-            app_name (str): The name of the application that was loaded.
-        """
-        if not self.enabled:
-            return
-        try:
-            properties = {
-                "version": self.get_version(),
-                "app_name": app_name,
-                "user_id": self.user_id,
-            }
-            posthog.capture("app_loaded", properties=properties)
-        except Exception as e:
-            logger.error(f"Failed to track app_loaded event: {e}")
-
-    def track_tool_called(
-        self,
-        tool_name: str,
-        app_name: str,
-        status: str,
-        error: str | None = None,
-    ):
-        """Tracks an event when a tool is called within an application.
-
-        This event provides insights into tool usage patterns, success rates,
-        and potential errors.
-
-        Args:
-            tool_name (str): The name of the tool that was called.
-            app_name (str): The name of the application the tool belongs to.
-            status (str): The status of the tool call (e.g., "success", "error").
-            error (str, optional): The error message if the tool call failed.
-                                 Defaults to None.
-        """
-        if not self.enabled:
-            return
-        try:
-            properties = {
-                "tool_name": tool_name,
-                "app_name": app_name,
-                "status": status,
-                "error": error,
-                "version": self.get_version(),
-                "user_id": self.user_id,
-            }
-            posthog.capture("tool_called", properties=properties)
-        except Exception as e:
-            logger.error(f"Failed to track tool_called event: {e}")
-
-
-analytics = Analytics()