lionagi 0.17.2__tar.gz → 0.17.4__tar.gz

{lionagi-0.17.2 → lionagi-0.17.4}/.github/workflows/ci.yml

@@ -27,18 +27,10 @@ jobs:
         curl -LsSf https://astral.sh/uv/install.sh | sh
         echo "$HOME/.cargo/bin" >> $GITHUB_PATH
     
-    - name: Load cached dependencies
-      id: cached-uv-dependencies
-      uses: actions/cache@v4
-      with:
-        path: .venv
-        key: venv-${{ runner.os }}-${{ matrix.python-version }}-${{ hashFiles('pyproject.toml') }}
-    
     - name: Install dependencies
-      if: steps.cached-uv-dependencies.outputs.cache-hit != 'true'
       run: |
         uv venv
-        uv sync --extra all
+        uv sync --all-extras
 
     - name: Run tests with coverage
       run: |

{lionagi-0.17.2 → lionagi-0.17.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.17.2
+Version: 0.17.4
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -374,6 +374,33 @@ print(result)
 The LLM can now open the PDF, read in slices, fetch references, and produce a
 final structured summary.
 
+### MCP (Model Context Protocol) Integration
+
+LionAGI supports Anthropic's Model Context Protocol for seamless tool integration:
+
+```
+pip install "lionagi[mcp]"
+```
+
+```python
+from lionagi import load_mcp_tools
+
+# Load tools from any MCP server
+tools = await load_mcp_tools(".mcp.json", ["search", "memory"])
+
+# Use with ReAct reasoning
+branch = Branch(chat_model=gpt4o, tools=tools)
+result = await branch.ReAct(
+    instruct={"instruction": "Research recent AI developments"},
+    tools=["search_exa_search"],
+    max_extensions=3
+)
+```
+
+- **Dynamic Discovery**: Auto-discover and register tools from MCP servers
+- **Type Safety**: Full Pydantic validation for tool interactions
+- **Connection Pooling**: Efficient resource management with automatic reuse
+
 ### Observability & Debugging
 
 - Inspect messages:

{lionagi-0.17.2 → lionagi-0.17.4}/README.md

@@ -110,6 +110,33 @@ print(result)
 The LLM can now open the PDF, read in slices, fetch references, and produce a
 final structured summary.
 
+### MCP (Model Context Protocol) Integration
+
+LionAGI supports Anthropic's Model Context Protocol for seamless tool integration:
+
+```
+pip install "lionagi[mcp]"
+```
+
+```python
+from lionagi import load_mcp_tools
+
+# Load tools from any MCP server
+tools = await load_mcp_tools(".mcp.json", ["search", "memory"])
+
+# Use with ReAct reasoning
+branch = Branch(chat_model=gpt4o, tools=tools)
+result = await branch.ReAct(
+    instruct={"instruction": "Research recent AI developments"},
+    tools=["search_exa_search"],
+    max_extensions=3
+)
+```
+
+- **Dynamic Discovery**: Auto-discover and register tools from MCP servers
+- **Type Safety**: Full Pydantic validation for tool interactions
+- **Connection Pooling**: Efficient resource management with automatic reuse
+
 ### Observability & Debugging
 
 - Inspect messages:

lionagi-0.17.4/cookbooks/using_mcp/.mcp.json

@@ -0,0 +1,14 @@
+{
+  "mcpServers": {
+    "search": {
+      "command": "/Users/lion/projects/lionagi/.venv/bin/python",
+      "args": [
+        "-m",
+        "khivemcp.cli",
+        "/Users/lion/projects/lionagi/cookbooks/using_mcp/search_group_config.json"
+      ],
+      "timeout": 300,
+      "alwaysAllow": []
+    }
+  }
+}

lionagi-0.17.4/cookbooks/using_mcp/README.md

@@ -0,0 +1,190 @@
+# Using MCP (Model Context Protocol) with LionAGI
+
+This cookbook demonstrates how to integrate MCP servers with LionAGI for dynamic
+tool discovery and execution.
+
+## What is MCP?
+
+The Model Context Protocol (MCP) is an open standard developed by Anthropic that
+enables seamless integration between AI models and external tools/data sources.
+It provides a unified protocol for:
+
+- Dynamic tool discovery
+- Standardized tool execution
+- Connection pooling for efficient resource management
+
+## Installation
+
+```bash
+pip install "lionagi[mcp]" khivemcp
+```
+
+## Quick Start
+
+### 1. Configure Your MCP Server
+
+Create a `.mcp.json` file to define your MCP servers:
+
+```json
+{
+  "mcpServers": {
+    "search": {
+      "command": "python",
+      "args": ["-m", "khivemcp.cli", "search_group_config.json"],
+      "timeout": 300
+    }
+  }
+}
+```
+
+### 2. Define Request Wrappers
+
+MCP tools expect requests wrapped in a specific format. Create Pydantic models
+to handle this:
+
+```python
+from pydantic import BaseModel
+from lionagi.service.third_party.exa_models import ExaSearchRequest
+from lionagi.service.third_party.pplx_models import PerplexityChatRequest
+
+class ExaRequest(BaseModel):
+    request: ExaSearchRequest
+
+class PerplexityRequest(BaseModel):
+    request: PerplexityChatRequest
+```
+
+### 3. Load and Use MCP Tools
+
+```python
+from lionagi import Branch, iModel
+from lionagi.protocols.action.manager import load_mcp_tools
+
+# Load tools with Pydantic validation
+tools = await load_mcp_tools(
+    ".mcp.json",
+    server_names=["search"],
+    request_options_map={
+        "search": {
+            "exa_search": ExaRequest,
+            "perplexity_search": PerplexityRequest,
+        }
+    }
+)
+
+# Use with Branch for ReAct reasoning
+branch = Branch(
+    chat_model=iModel(provider="openai", model="gpt-4.1-mini"),
+    tools=tools
+)
+
+result = await branch.ReAct(
+    instruct={
+        "instruction": "Research recent AI developments",
+        "context": {}
+    },
+    tools=["search_exa_search"],
+    max_extensions=3
+)
+```
+
+## Files in This Cookbook
+
+- **`.mcp.json`** - MCP server configuration
+- **`search_group_config.json`** - Configuration for the search service group
+- **`search_group.py`** - MCP server implementation with Exa and Perplexity
+  search
+- **`react_mcp_with_schema.py`** - Complete example using MCP tools with ReAct
+  reasoning
+
+## Key Features
+
+### Dynamic Tool Discovery
+
+MCP servers can be queried for available tools at runtime:
+
+```python
+from lionagi.protocols.action.manager import ActionManager
+
+manager = ActionManager()
+tools = await manager.register_mcp_server(
+    {"server": "search"},
+    update=True
+)
+```
+
+### Connection Pooling
+
+Efficient connection reuse across multiple tool invocations:
+
+```python
+from lionagi.service.connections.mcp.wrapper import MCPConnectionPool
+
+# Connections are automatically pooled and reused
+MCPConnectionPool.load_config(".mcp.json")
+client = await MCPConnectionPool.get_client({"server": "search"})
+```
+
+### Type Safety with Pydantic
+
+Full request/response validation using Pydantic models ensures type safety
+throughout the pipeline.
+
+## Advanced Configuration
+
+### Environment Variables
+
+Control MCP server logging and debugging:
+
+```bash
+export MCP_DEBUG=true           # Enable debug mode
+export LOG_LEVEL=ERROR          # Set logging level
+export FASTMCP_QUIET=true       # Suppress FastMCP output
+```
+
+### Custom MCP Servers
+
+Create your own MCP server by extending `ServiceGroup`:
+
+```python
+from khivemcp import ServiceGroup, operation
+
+class MyServiceGroup(ServiceGroup):
+    @operation(name="my_tool", schema=MyRequestModel)
+    async def my_tool(self, request: MyRequestModel):
+        # Tool implementation
+        return {"result": "success"}
+```
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Schema Mismatch**: Ensure your wrapper models correctly wrap the request
+   with a `request` field
+2. **Server Not Found**: Check that your `.mcp.json` paths are correct
+3. **Verbose Logging**: Set environment variables to suppress server output
+
+### Debug Mode
+
+Enable debug logging to troubleshoot issues:
+
+```python
+tools = await load_mcp_tools(
+    ".mcp.json",
+    server_names=["search"],
+    debug=True  # Enable debug mode
+)
+```
+
+## Resources
+
+- [MCP Specification](https://modelcontextprotocol.io)
+- [FastMCP Documentation](https://gofastmcp.com)
+- [KhiveMCP](https://github.com/khive-ai/khivemcp)
+- [LionAGI Documentation](https://github.com/lion-agi/lionagi)
+
+## License
+
+This cookbook is part of the LionAGI project and follows the same Apache 2.0
+license.

lionagi-0.17.4/cookbooks/using_mcp/react_mcp_with_schema.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""
+Test ReAct reasoning with MCP search tools and proper Pydantic schemas
+"""
+
+import asyncio
+
+from pydantic import BaseModel
+
+from lionagi import Branch, iModel
+from lionagi.protocols.action.manager import load_mcp_tools
+from lionagi.service.third_party.exa_models import ExaSearchRequest
+from lionagi.service.third_party.pplx_models import PerplexityChatRequest
+
+
+class ExaRequest(BaseModel):
+    request: ExaSearchRequest
+
+
+class PerplexityRequest(BaseModel):
+    request: PerplexityChatRequest
+
+
+async def test_react_with_mcp():
+    print("🦁 Testing ReAct with MCP Search Tools (with Pydantic schemas)")
+    print("=" * 60)
+
+    # 1. Load MCP search tools with proper Pydantic schemas
+    print("\n1. Loading MCP search tools with Pydantic validation...")
+    tools = await load_mcp_tools(
+        "/Users/lion/projects/lionagi/cookbooks/using_mcp/.mcp.json",
+        server_names=["search"],
+        request_options_map={
+            "search": {
+                "exa_search": ExaRequest,
+                "perplexity_search": PerplexityRequest,
+            }
+        },
+    )
+    print(f"   ✅ Loaded {len(tools)} search tools with schemas:")
+    for tool in tools:
+        print(
+            f"      - {tool.function} (has request_options: {tool.request_options is not None})"
+        )
+
+    # 2. Create a Branch with the tools
+    print("\n2. Creating Branch with gpt-4.1-mini...")
+    branch = Branch(
+        name="react_test",
+        chat_model=iModel(provider="openai", model="gpt-4.1-mini"),
+        tools=tools,
+    )
+    print("   ✅ Branch created")
+
+    # 3. Run ReAct reasoning
+    print("\n3. Running ReAct reasoning (max 3 extensions)...")
+    print(
+        "   Question: What are the latest developments in Model Context Protocol (MCP)?"
+    )
+    print("\n   Executing ReAct...")
+
+    try:
+        result = await branch.ReAct(
+            instruct={
+                "instruction": (
+                    "Research the latest developments in Model Context Protocol (MCP). "
+                    "Use the search tools to find recent information about MCP, "
+                    "its features, and adoption by different platforms."
+                ),
+                "context": {},
+            },
+            tools=["search_exa_search", "search_perplexity_search"],
+            max_extensions=3,
+            verbose=True,
+        )
+
+        print("\n4. ReAct Result:")
+        print("-" * 40)
+        if result:
+            # Print result content
+            if hasattr(result, "content"):
+                print(result.content)
+            else:
+                print(str(result))
+        print("-" * 40)
+
+    except Exception as e:
+        print(f"\n❌ ReAct failed: {e}")
+        import traceback
+
+        traceback.print_exc()
+
+    print("\n" + "=" * 60)
+    print("✅ Test Complete!")
+    print("\nKey improvements:")
+    print("  • Tools now have proper Pydantic schemas for validation")
+    print("  • Model knows exactly what parameters to provide")
+    print("  • Type safety and validation at runtime")
+
+
+if __name__ == "__main__":
+    asyncio.run(test_react_with_mcp())

lionagi-0.17.4/cookbooks/using_mcp/search_group.py

@@ -0,0 +1,80 @@
+import logging
+from typing import Literal
+
+from dotenv import load_dotenv
+from khivemcp import ServiceGroup, operation
+
+from lionagi import iModel
+from lionagi.service.connections.api_calling import APICalling
+from lionagi.service.third_party.exa_models import ExaSearchRequest
+from lionagi.service.third_party.pplx_models import PerplexityChatRequest
+
+logger = logging.getLogger(__name__)
+
+PROVIDERS = Literal["exa", "perplexity"]
+
+
+class SearchServiceGroup(ServiceGroup):
+    def __init__(self, config: dict | None = None):
+        """
+        Initialize the LLMServiceGroup.
+        """
+        load_dotenv()
+        super().__init__(config=config)
+        logger.info(
+            f"[LLMServiceGroup] Initialized.",
+        )
+        self.imodels = {}
+
+    @operation(name="exa_search", schema=ExaSearchRequest)
+    async def exa_search(self, request: ExaSearchRequest):
+        """Performs a search using Exa's search endpoint."""
+        if not "exa_search" in self.imodels:
+            self.imodels["exa_search"] = iModel(
+                provider="exa",
+                endpoint="search",
+                queue_capacity=5,
+                interval=1,
+                limit_requests=5,
+                api_key="EXA_API_KEY",
+            )
+
+        result: APICalling = await self.imodels["exa_search"].invoke(
+            **request.model_dump(exclude_none=True),
+            is_cached=True,
+        )
+        return {
+            "id": str(result.id),
+            "created_at": result.created_datetime.isoformat(),
+            "status": result.execution.status.value,
+            "duration": result.execution.duration,
+            "response": result.execution.response,
+            "error": result.execution.error,
+        }
+
+    @operation(name="perplexity_search", schema=PerplexityChatRequest)
+    async def perplexity_search(self, request: PerplexityChatRequest):
+        """Performs a search using Perplexity's chat completion endpoint."""
+        if not "perplexity_search" in self.imodels:
+            self.imodels["perplexity_search"] = iModel(
+                provider="perplexity",
+                endpoint="chat",
+                interval=60,
+                limit_tokens=20000,
+                api_key="PERPLEXITY_API_KEY",
+                limit_requests=10,
+            )
+
+        imodel = self.imodels["perplexity_search"]
+        result: APICalling = await imodel.invoke(
+            **request.model_dump(exclude_none=True),
+            is_cached=True,
+        )
+        return {
+            "id": str(result.id),
+            "created_at": result.created_datetime.isoformat(),
+            "status": result.execution.status.value,
+            "duration": result.execution.duration,
+            "response": result.execution.response,
+            "error": result.execution.error,
+        }

lionagi-0.17.4/cookbooks/using_mcp/search_group_config.json

@@ -0,0 +1,6 @@
+{
+  "name": "search",
+  "class_path": "cookbooks.using_mcp.search_group:SearchServiceGroup",
+  "description": "A group for searching information online.",
+  "env_vars": {}
+}

{lionagi-0.17.2 → lionagi-0.17.4}/lionagi/__init__.py

@@ -6,7 +6,6 @@ import logging
 
 from pydantic import BaseModel, Field
 
-# Eager imports for commonly used components
 from . import ln as ln
 from .operations.node import Operation
 from .service.imodel import iModel
@@ -35,6 +34,11 @@ def __getattr__(name: str):
 
         _lazy_imports["Builder"] = Builder
         return Builder
+    elif name == "load_mcp_tools":
+        from .protocols.action.manager import load_mcp_tools
+
+        _lazy_imports["load_mcp_tools"] = load_mcp_tools
+        return load_mcp_tools
 
     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")