langroid 0.52.8__py3-none-any.whl → 0.53.0__py3-none-any.whl

langroid/agent/tools/mcp/__init__.py

@@ -0,0 +1,10 @@
+from .decorators import mcp_tool
+from .fastmcp_client import FastMCPClient, make_mcp_tool_sync, make_mcp_tool
+
+
+__all__ = [
+    "mcp_tool",
+    "FastMCPClient",
+    "make_mcp_tool_sync",
+    "make_mcp_tool",
+]

langroid/agent/tools/mcp/decorators.py

@@ -0,0 +1,33 @@
+from typing import Callable, Type
+
+from langroid.agent.tool_message import ToolMessage
+from langroid.agent.tools.mcp.fastmcp_client import make_mcp_tool_sync
+
+
+def mcp_tool(
+    server: str, tool_name: str
+) -> Callable[[Type[ToolMessage]], Type[ToolMessage]]:
+    """Decorator: declare a ToolMessage class bound to a FastMCP tool.
+
+    Usage:
+        @fastmcp_tool("/path/to/server.py", "get_weather")
+        class WeatherTool:
+            def pretty(self) -> str:
+                return f"Temp is {self.temperature}"
+    """
+
+    def decorator(user_cls: Type[ToolMessage]) -> Type[ToolMessage]:
+        # build the “real” ToolMessage subclass for this server/tool
+        RealTool: Type[ToolMessage] = make_mcp_tool_sync(server, tool_name)
+
+        # copy user‐defined methods / attributes onto RealTool
+        for name, attr in user_cls.__dict__.items():
+            if name.startswith("__") and name.endswith("__"):
+                continue
+            setattr(RealTool, name, attr)
+
+        # preserve the user’s original name if you like:
+        RealTool.__name__ = user_cls.__name__
+        return RealTool
+
+    return decorator

langroid/agent/tools/mcp/fastmcp_client.py

@@ -0,0 +1,249 @@
+import asyncio
+import logging
+from typing import Any, Dict, List, Optional, Tuple, Type, cast
+
+from dotenv import load_dotenv
+from fastmcp.client import Client
+from fastmcp.client.transports import ClientTransport
+from fastmcp.server import FastMCP
+from mcp.types import CallToolResult, TextContent, Tool
+
+from langroid.agent.tool_message import ToolMessage
+from langroid.pydantic_v1 import BaseModel, Field, create_model
+
+load_dotenv()  # load environment variables from .env
+
+
+class FastMCPClient:
+    """A client for interacting with a FastMCP server.
+
+    Provides async context manager functionality to safely manage resources.
+    """
+
+    logger = logging.getLogger(__name__)
+    _cm: Optional[Client] = None
+    client: Optional[Client] = None
+
+    def __init__(self, server: str | FastMCP[Any] | ClientTransport) -> None:
+        """Initialize the FastMCPClient.
+
+        Args:
+            server: FastMCP server or path to such a server
+        """
+        self.server = server
+        self.client = None
+        self._cm = None
+
+    async def __aenter__(self) -> "FastMCPClient":
+        """Enter the async context manager and connect inner client."""
+        # create inner client context manager
+        self._cm = Client(self.server)
+        # actually enter it (opens the session)
+        self.client = await self._cm.__aenter__()  # type: ignore
+        return self
+
+    async def connect(self) -> None:
+        """Open the underlying session."""
+        await self.__aenter__()
+
+    async def close(self) -> None:
+        """Close the underlying session."""
+        await self.__aexit__(None, None, None)
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[type[Exception]],
+        exc_val: Optional[Exception],
+        exc_tb: Optional[Any],
+    ) -> None:
+        """Exit the async context manager and close inner client."""
+        # exit and close the inner fastmcp.Client
+        if hasattr(self, "_cm"):
+            if self._cm is not None:
+                await self._cm.__aexit__(exc_type, exc_val, exc_tb)  # type: ignore
+        self.client = None
+        self._cm = None
+
+    def _schema_to_field(
+        self, name: str, schema: Dict[str, Any], prefix: str
+    ) -> Tuple[Any, Any]:
+        """Convert a JSON Schema snippet into a (type, Field) tuple.
+
+        Args:
+            name: Name of the field.
+            schema: JSON Schema for this field.
+            prefix: Prefix to use for nested model names.
+
+        Returns:
+            A tuple of (python_type, Field(...)) for create_model.
+        """
+        t = schema.get("type")
+        default = schema.get("default", ...)
+        desc = schema.get("description")
+        # Object → nested BaseModel
+        if t == "object" and "properties" in schema:
+            sub_name = f"{prefix}_{name.capitalize()}"
+            sub_fields: Dict[str, Tuple[type, Any]] = {}
+            for k, sub_s in schema["properties"].items():
+                ftype, fld = self._schema_to_field(sub_name + k, sub_s, sub_name)
+                sub_fields[k] = (ftype, fld)
+            submodel = create_model(  # type: ignore
+                sub_name,
+                __base__=BaseModel,
+                **sub_fields,
+            )
+            return submodel, Field(default=default, description=desc)  # type: ignore
+        # Array → List of items
+        if t == "array" and "items" in schema:
+            item_type, _ = self._schema_to_field(name, schema["items"], prefix)
+            return List[item_type], Field(default=default, description=desc)  # type: ignore
+        # Primitive types
+        if t == "string":
+            return str, Field(default=default, description=desc)
+        if t == "integer":
+            return int, Field(default=default, description=desc)
+        if t == "number":
+            return float, Field(default=default, description=desc)
+        if t == "boolean":
+            return bool, Field(default=default, description=desc)
+        # Fallback or unions
+        if any(key in schema for key in ("oneOf", "anyOf", "allOf")):
+            self.logger.warning("Unsupported union schema in field %s; using Any", name)
+            return Any, Field(default=default, description=desc)
+        # Default fallback
+        return Any, Field(default=default, description=desc)
+
+    async def make_tool(self, tool_name: str) -> Type[ToolMessage]:
+        """Create a Langroid ToolMessage subclass for the given tool name."""
+        if not self.client:
+            raise RuntimeError("Client not initialized. Use async with FastMCPClient.")
+        target = await self.find_mcp_tool(tool_name)
+        if target is None:
+            raise ValueError(f"No tool named {tool_name}")
+        props = target.inputSchema.get("properties", {})
+        fields: Dict[str, Tuple[type, Any]] = {}
+        for fname, schema in props.items():
+            ftype, fld = self._schema_to_field(fname, schema, target.name)
+            fields[fname] = (ftype, fld)
+
+        # Convert target.name to CamelCase and add Tool suffix
+        parts = target.name.replace("-", "_").split("_")
+        camel_case = "".join(part.capitalize() for part in parts)
+        model_name = f"{camel_case}Tool"
+
+        # create Langroid ToolMessage subclass, with expected fields.
+        tool_model = cast(
+            Type[ToolMessage],
+            create_model(  # type: ignore[call-overload]
+                model_name,
+                request=(str, target.name),
+                purpose=(str, target.description or f"Use the tool {target.name}"),
+                __base__=ToolMessage,
+                **fields,
+            ),
+        )
+        tool_model._server = self.server  # type: ignore[attr-defined]
+
+        # 2) define an arg-free call_tool_async()
+        async def call_tool_async(self: ToolMessage) -> Any:
+            from langroid.agent.tools.mcp.fastmcp_client import FastMCPClient
+
+            # pack up the payload
+            payload = self.dict(exclude=self.Config.schema_extra["exclude"])
+            # open a fresh client, call the tool, then close
+            async with FastMCPClient(self.__class__._server) as client:  # type: ignore
+                return await client.call_mcp_tool(self.request, payload)
+
+        tool_model.call_tool_async = call_tool_async  # type: ignore
+
+        if not hasattr(tool_model, "handle_async"):
+            # 3) define an arg-free handle_async() method
+            # if the tool model doesn't already have one
+            async def handle_async(self: ToolMessage) -> Any:
+                return await self.call_tool_async()  # type: ignore[attr-defined]
+
+            # add the handle_async() method to the tool model
+            tool_model.handle_async = handle_async  # type: ignore
+
+        return tool_model
+
+    async def get_tools(self) -> List[Type[ToolMessage]]:
+        """
+        Get all available tools as Langroid ToolMessage classes,
+        handling nested schemas, with `handle_async` methods
+        """
+        if not self.client:
+            raise RuntimeError("Client not initialized. Use async with FastMCPClient.")
+        resp = await self.client.list_tools()
+        tools: List[Type[ToolMessage]] = []
+        for t in resp:
+            tools.append(await self.make_tool(t.name))
+        return tools
+
+    async def find_mcp_tool(self, name: str) -> Optional[Tool]:
+        """Find the MCP Tool matching `name`, or None if missing.
+
+        Args:
+            name: Name of the tool to look up.
+
+        Returns:
+            The raw Tool object from the server, or None.
+        """
+        if not self.client:
+            raise RuntimeError("Client not initialized. Use async with FastMCPClient.")
+        resp: List[Tool] = await self.client.list_tools()
+        return next((t for t in resp if t.name == name), None)
+
+    def _convert_tool_result(
+        self,
+        tool_name: str,
+        result: CallToolResult,
+    ) -> List[str] | str | None:
+        if result.isError:
+            self.logger.error(f"Error calling MCP tool {tool_name}")
+            return None
+        has_nontext_results = any(
+            not isinstance(item, TextContent) for item in result.content
+        )
+        if has_nontext_results:
+            self.logger.warning(
+                f"""
+                MCP Tool {tool_name} returned non-text results,
+                which will be skipped.
+                """,
+            )
+        results = [
+            item.text for item in result.content if isinstance(item, TextContent)
+        ]
+        if len(results) == 1:
+            return results[0]
+        return results
+
+    async def call_mcp_tool(
+        self, tool_name: str, arguments: Dict[str, Any]
+    ) -> str | List[str] | None:
+        """Call an MCP tool with the given arguments.
+
+        Args:
+            tool_name: Name of the tool to call.
+            arguments: Arguments to pass to the tool.
+
+        Returns:
+            The result of the tool call.
+        """
+        if not self.client:
+            raise RuntimeError("Client not initialized. Use async with FastMCPClient.")
+        result: CallToolResult = await self.client.session.call_tool(
+            tool_name,
+            arguments,
+        )
+        return self._convert_tool_result(tool_name, result)
+
+
+async def make_mcp_tool(server: str, tool_name: str) -> Type[ToolMessage]:
+    async with FastMCPClient(server) as client:
+        return await client.make_tool(tool_name)
+
+
+def make_mcp_tool_sync(server: str, tool_name: str) -> Type[ToolMessage]:
+    return asyncio.run(make_mcp_tool(server, tool_name))

langroid/language_models/base.py

@@ -99,9 +99,8 @@ class LLMConfig(BaseSettings):
 
     @property
     def model_max_output_tokens(self) -> int:
-        return min(
-            self.max_output_tokens or get_model_info(self.chat_model).max_output_tokens,
-            get_model_info(self.chat_model).max_output_tokens,
+        return (
+            self.max_output_tokens or get_model_info(self.chat_model).max_output_tokens
         )
 
 

langroid/language_models/model_info.py

@@ -23,7 +23,7 @@ class ModelName(str, Enum):
 class OpenAIChatModel(ModelName):
     """Enum for OpenAI Chat models"""
 
-    GPT3_5_TURBO = "gpt-3.5-turbo-1106"
+    GPT3_5_TURBO = "gpt-3.5-turbo"
     GPT4 = "gpt-4o"  # avoid deprecated gpt-4
     GPT4_TURBO = "gpt-4-turbo"
     GPT4o = "gpt-4o"

{langroid-0.52.8.dist-info → langroid-0.53.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langroid
-Version: 0.52.8
+Version: 0.53.0
 Summary: Harness LLMs with Multi-Agent Programming
 Author-email: Prasad Chalasani <pchalasani@gmail.com>
 License: MIT
@@ -17,6 +17,7 @@ Requires-Dist: duckduckgo-search<7.0.0,>=6.0.0
 Requires-Dist: exa-py>=1.8.7
 Requires-Dist: faker<19.0.0,>=18.9.0
 Requires-Dist: fakeredis<3.0.0,>=2.12.1
+Requires-Dist: fastmcp>=2.2.5
 Requires-Dist: fire<1.0.0,>=0.5.0
 Requires-Dist: gitpython<4.0.0,>=3.1.43
 Requires-Dist: google-api-python-client<3.0.0,>=2.95.0

{langroid-0.52.8.dist-info → langroid-0.53.0.dist-info}/RECORD

@@ -54,6 +54,9 @@ langroid/agent/tools/retrieval_tool.py,sha256=zcAV20PP_6VzSd-UE-IJcabaBseFL_QNz5
 langroid/agent/tools/rewind_tool.py,sha256=XAXL3BpNhCmBGYq_qi_sZfHJuIw7NY2jp4wnojJ7WRs,5606
 langroid/agent/tools/segment_extract_tool.py,sha256=__srZ_VGYLVOdPrITUM8S0HpmX4q7r5FHWMDdHdEv8w,1440
 langroid/agent/tools/tavily_search_tool.py,sha256=soI-j0HdgVQLf09wRQScaEK4b5RpAX9C4cwOivRFWWI,1903
+langroid/agent/tools/mcp/__init__.py,sha256=aMW4cRepRbE44iCGQu_fQF623bN8Q1HHBbRMGaO22kY,210
+langroid/agent/tools/mcp/decorators.py,sha256=zyV8iYq3dg3taHEkaC5aNncyb4UdNBp-i1tRhMOFkd4,1147
+langroid/agent/tools/mcp/fastmcp_client.py,sha256=goj7GSbez28cFaa-KmQRavw7MY_hHUCYhKP0fUZLDms,9548
 langroid/cachedb/__init__.py,sha256=G2KyNnk3Qkhv7OKyxTOnpsxfDycx3NY0O_wXkJlalNY,96
 langroid/cachedb/base.py,sha256=ztVjB1DtN6pLCujCWnR6xruHxwVj3XkYniRTYAKKqk0,1354
 langroid/cachedb/redis_cachedb.py,sha256=7kgnbf4b5CKsCrlL97mHWKvdvlLt8zgn7lc528jEpiE,5141
@@ -68,10 +71,10 @@ langroid/embedding_models/protoc/embeddings_pb2.pyi,sha256=UkNy7BrNsmQm0vLb3NtGX
 langroid/embedding_models/protoc/embeddings_pb2_grpc.py,sha256=9dYQqkW3JPyBpSEjeGXTNpSqAkC-6FPtBHyteVob2Y8,2452
 langroid/language_models/__init__.py,sha256=3aD2qC1lz8v12HX4B-dilv27gNxYdGdeu1QvDlkqqHs,1095
 langroid/language_models/azure_openai.py,sha256=SW0Fp_y6HpERr9l6TtF6CYsKgKwjUf_hSL_2mhTV4wI,5034
-langroid/language_models/base.py,sha256=pfN3t-BktKmN_4K8pwmpjC9OdcHxsytM5s5TmsJ-nPg,28560
+langroid/language_models/base.py,sha256=Axj8U9o9r7ovpCYqhNJ4SaVYLvufLRQXnr51IyIYJKY,28493
 langroid/language_models/config.py,sha256=9Q8wk5a7RQr8LGMT_0WkpjY8S4ywK06SalVRjXlfCiI,378
 langroid/language_models/mock_lm.py,sha256=5BgHKDVRWFbUwDT_PFgTZXz9-k8wJSA2e3PZmyDgQ1k,4022
-langroid/language_models/model_info.py,sha256=vOaTi-XFKnz-BvHUvgjnt0XfOtl21Apev3Zy7Rhckbw,14458
+langroid/language_models/model_info.py,sha256=7Fv5YByZjsRXKhkaa6okOM8jhDVpWZu6xlYAN3WTSCk,14453
 langroid/language_models/openai_gpt.py,sha256=F28jqTEerN32m14q3K0oc3vnvBT8J7Q9xqXGZNKUjKU,85938
 langroid/language_models/utils.py,sha256=n55Oe2_V_4VNGhytvPWLYC-0tFS07RTjN83KWl-p_MI,6032
 langroid/language_models/prompt_formatter/__init__.py,sha256=2-5cdE24XoFDhifOLl8yiscohil1ogbP1ECkYdBlBsk,372
@@ -129,7 +132,7 @@ langroid/vector_store/pineconedb.py,sha256=otxXZNaBKb9f_H75HTaU3lMHiaR2NUp5MqwLZ
 langroid/vector_store/postgres.py,sha256=wHPtIi2qM4fhO4pMQr95pz1ZCe7dTb2hxl4VYspGZoA,16104
 langroid/vector_store/qdrantdb.py,sha256=O6dSBoDZ0jzfeVBd7LLvsXu083xs2fxXtPa9gGX3JX4,18443
 langroid/vector_store/weaviatedb.py,sha256=Yn8pg139gOy3zkaPfoTbMXEEBCiLiYa1MU5d_3UA1K4,11847
-langroid-0.52.8.dist-info/METADATA,sha256=v0NjlHl9pXUfWPYH4-Gobzo4fYN9fcCpDaFG3cPFX-A,63519
-langroid-0.52.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langroid-0.52.8.dist-info/licenses/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
-langroid-0.52.8.dist-info/RECORD,,
+langroid-0.53.0.dist-info/METADATA,sha256=JohvBH6oCb3ki2nsiIcPT0IiNmmn0dM2eNjQ9lsLn5E,63549
+langroid-0.53.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langroid-0.53.0.dist-info/licenses/LICENSE,sha256=EgVbvA6VSYgUlvC3RvPKehSg7MFaxWDsFuzLOsPPfJg,1065
+langroid-0.53.0.dist-info/RECORD,,