universal-mcp 0.1.13rc14__py3-none-any.whl → 0.1.15__py3-none-any.whl

universal_mcp/cli.py

@@ -2,7 +2,7 @@ import re
 from pathlib import Path
 
 import typer
-from rich import print as rprint
+from rich.console import Console
 from rich.panel import Panel
 
 from universal_mcp.utils.installation import (
@@ -11,6 +11,9 @@ from universal_mcp.utils.installation import (
     install_cursor,
 )
 
+# Setup rich console and logging
+console = Console()
+
 app = typer.Typer()
 
 
@@ -36,10 +39,10 @@ def generate(
     This name will be used for the folder in applications/.
     """
     # Import here to avoid circular imports
-    from universal_mcp.utils.api_generator import generate_api_from_schema
+    from universal_mcp.utils.openapi.api_generator import generate_api_from_schema
 
     if not schema_path.exists():
-        typer.echo(f"Error: Schema file {schema_path} does not exist", err=True)
+        console.print(f"[red]Error: Schema file {schema_path} does not exist[/red]")
         raise typer.Exit(1)
 
     try:
@@ -49,28 +52,22 @@ def generate(
             output_path=output_path,
             class_name=class_name,
         )
-        typer.echo("API client successfully generated and installed.")
-        typer.echo(f"Application file: {app_file}")
+        console.print("[green]API client successfully generated and installed.[/green]")
+        console.print(f"[blue]Application file: {app_file}[/blue]")
     except Exception as e:
-        typer.echo(f"Error generating API client: {e}", err=True)
+        console.print(f"[red]Error generating API client: {e}[/red]")
         raise typer.Exit(1) from e
 
 
 @app.command()
 def readme(
     file_path: Path = typer.Argument(..., help="Path to the Python file to process"),
-    class_name: str = typer.Option(
-        None,
-        "--class-name",
-        "-c",
-        help="Class name to use for the API client",
-    ),
 ):
     """Generate a README.md file for the API client."""
-    from universal_mcp.utils.readme import generate_readme
+    from universal_mcp.utils.openapi.readme import generate_readme
 
-    readme_file = generate_readme(file_path, class_name)
-    typer.echo(f"README.md file generated at: {readme_file}")
+    readme_file = generate_readme(file_path)
+    console.print(f"[green]README.md file generated at: {readme_file}[/green]")
 
 
 @app.command()
@@ -88,17 +85,17 @@ def docgen(
     This command uses litellm with structured output to generate high-quality
     Google-style docstrings for all functions in the specified Python file.
     """
-    from universal_mcp.utils.docgen import process_file
+    from universal_mcp.utils.openapi.docgen import process_file
 
     if not file_path.exists():
-        typer.echo(f"Error: File not found: {file_path}", err=True)
+        console.print(f"[red]Error: File not found: {file_path}[/red]")
         raise typer.Exit(1)
 
     try:
         processed = process_file(str(file_path), model)
-        typer.echo(f"Successfully processed {processed} functions")
+        console.print(f"[green]Successfully processed {processed} functions[/green]")
     except Exception as e:
-        typer.echo(f"Error: {e}", err=True)
+        console.print(f"[red]Error: {e}[/red]")
         raise typer.Exit(1) from e
 
 
@@ -130,15 +127,14 @@ def install(app_name: str = typer.Argument(..., help="Name of app to install")):
     supported_apps = get_supported_apps()
 
     if app_name not in supported_apps:
-        typer.echo("Available apps:")
+        console.print("[yellow]Available apps:[/yellow]")
         for app in supported_apps:
-            typer.echo(f"  - {app}")
-        typer.echo(f"\nApp '{app_name}' not supported")
+            console.print(f"  - {app}")
+        console.print(f"\n[red]App '{app_name}' not supported[/red]")
         raise typer.Exit(1)
 
     # Print instructions before asking for API key
-
-    rprint(
+    console.print(
         Panel(
             "API key is required. Visit [link]https://agentr.dev[/link] to create an API key.",
             title="Instruction",
@@ -156,15 +152,15 @@ def install(app_name: str = typer.Argument(..., help="Name of app to install")):
     )
     try:
         if app_name == "claude":
-            typer.echo(f"Installing mcp server for: {app_name}")
+            console.print(f"[blue]Installing mcp server for: {app_name}[/blue]")
             install_claude(api_key)
-            typer.echo("App installed successfully")
+            console.print("[green]App installed successfully[/green]")
         elif app_name == "cursor":
-            typer.echo(f"Installing mcp server for: {app_name}")
+            console.print(f"[blue]Installing mcp server for: {app_name}[/blue]")
             install_cursor(api_key)
-            typer.echo("App installed successfully")
+            console.print("[green]App installed successfully[/green]")
     except Exception as e:
-        typer.echo(f"Error installing app: {e}", err=True)
+        console.print(f"[red]Error installing app: {e}[/red]")
         raise typer.Exit(1) from e
 
 
@@ -198,9 +194,8 @@ def init(
 
     def validate_pattern(value: str, field_name: str) -> None:
         if not re.match(NAME_PATTERN, value):
-            typer.secho(
-                f"❌ Invalid {field_name}; only letters, numbers, hyphens, and underscores allowed.",
-                fg=typer.colors.RED,
+            console.print(
+                f"[red]❌ Invalid {field_name}; only letters, numbers, hyphens, and underscores allowed.[/red]"
             )
             raise typer.Exit(code=1)
 
@@ -212,7 +207,7 @@ def init(
             prompt_suffix=" (e.g., reddit, youtube): ",
         ).strip()
     validate_pattern(app_name, "app name")
-
+    app_name = app_name.lower()
     if not output_dir:
         path_str = typer.prompt(
             "Enter the output directory for the project",
@@ -224,20 +219,17 @@ def init(
     if not output_dir.exists():
         try:
             output_dir.mkdir(parents=True, exist_ok=True)
-            typer.secho(
-                f"✅ Created output directory at '{output_dir}'",
-                fg=typer.colors.GREEN,
+            console.print(
+                f"[green]✅ Created output directory at '{output_dir}'[/green]"
             )
         except Exception as e:
-            typer.secho(
-                f"❌ Failed to create output directory '{output_dir}': {e}",
-                fg=typer.colors.RED,
+            console.print(
+                f"[red]❌ Failed to create output directory '{output_dir}': {e}[/red]"
             )
             raise typer.Exit(code=1) from e
     elif not output_dir.is_dir():
-        typer.secho(
-            f"❌ Output path '{output_dir}' exists but is not a directory.",
-            fg=typer.colors.RED,
+        console.print(
+            f"[red]❌ Output path '{output_dir}' exists but is not a directory.[/red]"
         )
         raise typer.Exit(code=1)
 
@@ -249,13 +241,12 @@ def init(
             prompt_suffix=" (api_key, oauth, agentr, none): ",
         ).lower()
     if integration_type not in ("api_key", "oauth", "agentr", "none"):
-        typer.secho(
-            "❌ Integration type must be one of: api_key, oauth, agentr, none",
-            fg=typer.colors.RED,
+        console.print(
+            "[red]❌ Integration type must be one of: api_key, oauth, agentr, none[/red]"
         )
         raise typer.Exit(code=1)
 
-    typer.secho("🚀 Generating project using cookiecutter...", fg=typer.colors.BLUE)
+    console.print("[blue]🚀 Generating project using cookiecutter...[/blue]")
     try:
         cookiecutter(
             "https://github.com/AgentrDev/universal-mcp-app-template.git",
@@ -267,11 +258,20 @@ def init(
             },
         )
     except Exception as exc:
-        typer.secho(f"❌ Project generation failed: {exc}", fg=typer.colors.RED)
+        console.print(f"❌ Project generation failed: {exc}")
         raise typer.Exit(code=1) from exc
 
-    project_dir = output_dir / f"universal-mcp-{app_name}"
-    typer.secho(f"✅ Project created at {project_dir}", fg=typer.colors.GREEN)
+    project_dir = output_dir / f"{app_name}"
+    console.print(f"✅ Project created at {project_dir}")
+
+@app.command()
+def preprocess(
+    schema_path: Path = typer.Option(None, "--schema", "-s", help="Path to the OpenAPI schema file."),
+    output_path: Path = typer.Option(None, "--output", "-o", help="Path to save the processed schema."),
+):
+    from universal_mcp.utils.openapi.preprocessor import run_preprocessing
+    """Preprocess an OpenAPI schema using LLM to fill or enhance descriptions."""
+    run_preprocessing(schema_path, output_path)
 
 
 if __name__ == "__main__":

universal_mcp/config.py

@@ -1,32 +1,105 @@
-from typing import Literal
+from pathlib import Path
+from typing import Any, Literal
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field, SecretStr, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
 class StoreConfig(BaseModel):
-    name: str = "universal_mcp"
-    type: Literal["memory", "environment", "keyring", "agentr"]
+    """Configuration for credential storage."""
+
+    name: str = Field(default="universal_mcp", description="Name of the store")
+    type: Literal["memory", "environment", "keyring", "agentr"] = Field(
+        default="memory", description="Type of credential storage to use"
+    )
+    path: Path | None = Field(
+        default=None, description="Path to store credentials (if applicable)"
+    )
 
 
 class IntegrationConfig(BaseModel):
-    name: str
-    type: Literal["api_key", "oauth", "agentr", "oauth2"]
-    credentials: dict | None = None
-    store: StoreConfig | None = None
+    """Configuration for API integrations."""
+
+    name: str = Field(..., description="Name of the integration")
+    type: Literal["api_key", "oauth", "agentr", "oauth2"] = Field(
+        default="api_key", description="Type of authentication to use"
+    )
+    credentials: dict[str, Any] | None = Field(
+        default=None, description="Integration-specific credentials"
+    )
+    store: StoreConfig | None = Field(
+        default=None, description="Store configuration for credentials"
+    )
 
 
 class AppConfig(BaseModel):
-    name: str
-    integration: IntegrationConfig | None = None
-    actions: list[str] | None = None
-
-
-class ServerConfig(BaseModel):
-    name: str = "Universal MCP"
-    description: str = "Universal MCP"
-    api_key: str | None = None
-    type: Literal["local", "agentr"] = "agentr"
-    transport: Literal["stdio", "sse", "http"] = "stdio"
-    port: int = 8005
-    apps: list[AppConfig] | None = None
-    store: StoreConfig | None = None
+    """Configuration for individual applications."""
+
+    name: str = Field(..., description="Name of the application")
+    integration: IntegrationConfig | None = Field(
+        default=None, description="Integration configuration"
+    )
+    actions: list[str] | None = Field(
+        default=None, description="List of available actions"
+    )
+
+
+class ServerConfig(BaseSettings):
+    """Main server configuration."""
+
+    model_config = SettingsConfigDict(
+        env_prefix="MCP_",
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=True,
+        extra="allow",
+    )
+
+    name: str = Field(default="Universal MCP", description="Name of the MCP server")
+    description: str = Field(
+        default="Universal MCP", description="Description of the MCP server"
+    )
+    api_key: SecretStr | None = Field(
+        default=None, description="API key for authentication"
+    )
+    type: Literal["local", "agentr"] = Field(
+        default="agentr", description="Type of server deployment"
+    )
+    transport: Literal["stdio", "sse", "http"] = Field(
+        default="stdio", description="Transport protocol to use"
+    )
+    port: int = Field(
+        default=8005, description="Port to run the server on (if applicable)"
+    )
+    host: str = Field(
+        default="localhost", description="Host to bind the server to (if applicable)"
+    )
+    apps: list[AppConfig] | None = Field(
+        default=None, description="List of configured applications"
+    )
+    store: StoreConfig | None = Field(
+        default=None, description="Default store configuration"
+    )
+    debug: bool = Field(default=False, description="Enable debug mode")
+    log_level: str = Field(default="INFO", description="Logging level")
+    max_connections: int = Field(
+        default=100, description="Maximum number of concurrent connections"
+    )
+    request_timeout: int = Field(
+        default=60, description="Default request timeout in seconds"
+    )
+
+    @field_validator("log_level", mode="before")
+    def validate_log_level(cls, v: str) -> str:
+        valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
+        if v.upper() not in valid_levels:
+            raise ValueError(
+                f"Invalid log level. Must be one of: {', '.join(valid_levels)}"
+            )
+        return v.upper()
+
+    @field_validator("port", mode="before")
+    def validate_port(cls, v: int) -> int:
+        if not 1 <= v <= 65535:
+            raise ValueError("Port must be between 1 and 65535")
+        return v

universal_mcp/exceptions.py

@@ -11,3 +11,11 @@ class ToolError(Exception):
 
 class InvalidSignature(Exception):
     """Raised when a signature is invalid."""
+
+
+class StoreError(Exception):
+    """Base exception class for store-related errors."""
+
+
+class KeyNotFoundError(StoreError):
+    """Exception raised when a key is not found in the store."""

universal_mcp/integrations/integration.py

@@ -6,7 +6,7 @@ from loguru import logger
 
 from universal_mcp.exceptions import NotAuthorizedError
 from universal_mcp.stores import BaseStore
-from universal_mcp.stores.store import KeyNotFoundError
+from universal_mcp.stores.store import KeyNotFoundError, MemoryStore
 from universal_mcp.utils.agentr import AgentrClient
 
 
@@ -91,7 +91,7 @@ class ApiKeyIntegration(Integration):
         store: Store instance for persisting credentials and other data
     """
 
-    def __init__(self, name: str, store: BaseStore | None = None, **kwargs):
+    def __init__(self, name: str, store: BaseStore = MemoryStore(), **kwargs):
         self.type = "api_key"
         sanitized_name = sanitize_api_key_name(name)
         super().__init__(sanitized_name, store, **kwargs)
@@ -109,6 +109,22 @@ class ApiKeyIntegration(Integration):
                 raise NotAuthorizedError(action) from e
         return self._api_key
 
+    @api_key.setter
+    def api_key(self, value: str | None) -> None:
+        """Set the API key.
+
+        Args:
+            value: The API key value to set.
+
+        Raises:
+            ValueError: If the API key is invalid.
+        """
+        if value is not None and not isinstance(value, str):
+            raise ValueError("API key must be a string")
+        self._api_key = value
+        if value is not None:
+            self.store.set(self.name, value)
+
     def get_credentials(self) -> dict[str, str]:
         """Get API key credentials.
 

universal_mcp/logger.py

@@ -1,17 +1,68 @@
 import sys
+from datetime import datetime
+from pathlib import Path
 
 from loguru import logger
 
 
-def setup_logger():
+def setup_logger(
+    log_file: Path | None = None,
+    rotation: str = "10 MB",
+    retention: str = "1 week",
+    compression: str = "zip",
+    level: str = "INFO",
+    format: str = "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",
+) -> None:
+    """Setup the logger with both stderr and optional file logging with rotation.
+
+    Args:
+        log_file: Optional path to log file. If None, only stderr logging is enabled.
+        rotation: When to rotate the log file. Can be size (e.g., "10 MB") or time (e.g., "1 day").
+        retention: How long to keep rotated log files (e.g., "1 week").
+        compression: Compression format for rotated logs ("zip", "gz", or None).
+        level: Minimum logging level.
+        format: Log message format string.
+    """
+    # Remove default handler
     logger.remove()
-    # STDOUT cant be used as a sink because it will break the stream
-    # logger.add(
-    #     sink=sys.stdout,
-    #     level="INFO",
-    # )
-    # STDERR
+
+    # Add stderr handler
     logger.add(
         sink=sys.stderr,
-        level="INFO",
+        level=level,
+        format=format,
+        enqueue=True,
+        backtrace=True,
+        diagnose=True,
     )
+
+    # Add file handler if log_file is specified
+    if log_file:
+        # Ensure log directory exists
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+
+        logger.add(
+            sink=str(log_file),
+            rotation=rotation,
+            retention=retention,
+            compression=compression,
+            level=level,
+            format=format,
+            enqueue=True,
+            backtrace=True,
+            diagnose=True,
+        )
+
+
+def get_log_file_path(app_name: str) -> Path:
+    """Get a standardized log file path for an application.
+
+    Args:
+        app_name: Name of the application.
+
+    Returns:
+        Path to the log file in the format: logs/{app_name}/{app_name}_{date}.log
+    """
+    date_str = datetime.now().strftime("%Y%m%d")
+    log_dir = Path("logs") / app_name
+    return log_dir / f"{app_name}_{date_str}.log"

universal_mcp/servers/__init__.py

@@ -1,5 +1,5 @@
 from universal_mcp.config import ServerConfig
-from universal_mcp.servers.server import AgentRServer, LocalServer
+from universal_mcp.servers.server import AgentRServer, LocalServer, SingleMCPServer
 
 
 def server_from_config(config: ServerConfig):
@@ -12,4 +12,4 @@ def server_from_config(config: ServerConfig):
         raise ValueError(f"Unsupported server type: {config.type}")
 
 
-__all__ = [AgentRServer, LocalServer, server_from_config]
+__all__ = [AgentRServer, LocalServer, SingleMCPServer, server_from_config]

universal_mcp/stores/store.py

@@ -5,17 +5,7 @@ from typing import Any
 import keyring
 from loguru import logger
 
-
-class StoreError(Exception):
-    """Base exception class for store-related errors."""
-
-    pass
-
-
-class KeyNotFoundError(StoreError):
-    """Exception raised when a key is not found in the store."""
-
-    pass
+from universal_mcp.exceptions import KeyNotFoundError, StoreError
 
 
 class BaseStore(ABC):
@@ -84,7 +74,7 @@ class MemoryStore(BaseStore):
 
     def __init__(self):
         """Initialize an empty dictionary to store the data."""
-        self.data: dict[str, str] = {}
+        self.data: dict[str, Any] = {}
 
     def get(self, key: str) -> Any:
         """

universal_mcp/tools/__init__.py

@@ -1,3 +1,15 @@
-from .tools import Tool, ToolManager
+from .adapters import (
+    convert_tool_to_langchain_tool,
+    convert_tool_to_mcp_tool,
+    convert_tool_to_openai_tool,
+)
+from .manager import ToolManager
+from .tools import Tool
 
-__all__ = ["Tool", "ToolManager"]
+__all__ = [
+    "Tool",
+    "ToolManager",
+    "convert_tool_to_langchain_tool",
+    "convert_tool_to_openai_tool",
+    "convert_tool_to_mcp_tool",
+]

universal_mcp/tools/adapters.py

@@ -1,6 +1,16 @@
+from enum import Enum
+
 from universal_mcp.tools.tools import Tool
 
 
+class ToolFormat(str, Enum):
+    """Supported tool formats."""
+
+    MCP = "mcp"
+    LANGCHAIN = "langchain"
+    OPENAI = "openai"
+
+
 def convert_tool_to_mcp_tool(
     tool: Tool,
 ):
@@ -40,4 +50,19 @@ def convert_tool_to_langchain_tool(
         description=tool.description or "",
         coroutine=call_tool,
         response_format="content",
+        args_schema=tool.parameters,
     )
+
+
+def convert_tool_to_openai_tool(
+    tool: Tool,
+):
+    """Convert a Tool object to an OpenAI function."""
+    return {
+        "type": "function",
+        "function": {
+            "name": tool.name,
+            "description": tool.description,
+            "parameters": tool.parameters,
+        },
+    }

universal_mcp/tools/func_metadata.py

@@ -61,7 +61,7 @@ class ArgModelBase(BaseModel):
         That is, sub-models etc are not dumped - they are kept as pydantic models.
         """
         kwargs: dict[str, Any] = {}
-        for field_name in self.model_fields:
+        for field_name in self.__class__.model_fields:
             kwargs[field_name] = getattr(self, field_name)
         return kwargs
 
@@ -82,6 +82,7 @@ class FuncMetadata(BaseModel):
         fn_is_async: bool,
         arguments_to_validate: dict[str, Any],
         arguments_to_pass_directly: dict[str, Any] | None,
+        context: dict[str, Any] | None = None,
     ) -> Any:
         """Call the given function with arguments validated and injected.
 
@@ -137,7 +138,10 @@ class FuncMetadata(BaseModel):
 
     @classmethod
     def func_metadata(
-        cls, func: Callable[..., Any], skip_names: Sequence[str] = ()
+        cls,
+        func: Callable[..., Any],
+        skip_names: Sequence[str] = (),
+        arg_description: dict[str, str] | None = None,
     ) -> "FuncMetadata":
         """Given a function, return metadata including a pydantic model representing its
         signature.
@@ -198,6 +202,12 @@ class FuncMetadata(BaseModel):
                 if param.default is not inspect.Parameter.empty
                 else PydanticUndefined,
             )
+            if (
+                not field_info.title
+                and arg_description
+                and arg_description.get(param.name)
+            ):
+                field_info.title = arg_description.get(param.name)
             dynamic_pydantic_model_params[param.name] = (
                 field_info.annotation,
                 field_info,