grll · grll · Mar 29, 2025 · Mar 28, 2025 · Mar 28, 2025 · Mar 28, 2025
diff --git a/README.md b/README.md
@@ -124,6 +124,7 @@ class YourFrameworkAdapter(ToolAdapter):
 - [ ] support for llamaindex
 - [ ] support for swarm
 - [x] support for crewAI
+- [x] support for google genai
 - [x] support for remote MCP Servers via SSE
 - [x] support for jupyter notebook
 - [x] add tests

diff --git a/examples/google_genai.py b/examples/google_genai.py
@@ -0,0 +1,79 @@
+"""
+Example of using the Google GenAI adapter with MCPAdapt.
+
+This example shows how to use the Google GenAI adapter with MCP to call a airbnb tool.
+
+Note: this whole example also work seamlessly synchronously.
+"""
+
+import os
+
+from google import genai  # type: ignore
+from google.genai import types  # type: ignore
+from mcp import StdioServerParameters
+
+from mcpadapt.core import MCPAdapt
+from mcpadapt.google_genai_adapter import GoogleGenAIAdapter
+
+client = genai.Client(
+    api_key=os.getenv("GEMINI_API_KEY")
+)  # Replace with your actual API key setup
+
+
+# Create server parameters for stdio connection
+server_params = StdioServerParameters(
+    command="npx",  # Executable
+    args=[
+        "-y",
+        "@openbnb/mcp-server-airbnb",
+        "--ignore-robots-txt",
+    ],  # Optional command line arguments
+    env=None,  # Optional environment variables
+)
+
+
+async def run():
+    async with MCPAdapt(
+        server_params,
+        GoogleGenAIAdapter(),
+    ) as adapted_tools:
+        # unpack tools and tool_functions
+        google_tools, tool_functions = zip(*adapted_tools)
+        tool_functions = dict(tool_functions)
+
+        prompt = "I want to book an apartment in Paris for 2 nights. 03/28 - 03/30"
+
+        # Send request with function declarations
+        response = client.models.generate_content(
+            model="gemini-2.0-flash",  # Or your preferred model supporting function calling
+            contents=prompt,
+            config=types.GenerateContentConfig(
+                temperature=0.7,
+                tools=google_tools,
+            ),  # Example other config
+        )
+
+        # Check for a function call
+        if response.candidates[0].content.parts[0].function_call:
+            function_call = response.candidates[0].content.parts[0].function_call
+            print(f"Function to call: {function_call.name}")
+            print(f"Arguments: {function_call.args}")
+            # In a real app, you would call your function here:
+            print(function_call.name)
+            print(function_call.args)
+            result = await tool_functions[function_call.name](function_call.args)
+
+            # here you could use result.isError to check if the tool call was successful
+            # or just extract the content assuming it's text:
+            text_content = result.content[0].text
+            print(text_content)
+            # sent new request with function call
+        else:
+            print("No function call found in the response.")
+            print(response.text)
+
+
+if __name__ == "__main__":
+    import asyncio
+
+    asyncio.run(run())
diff --git a/examples/smolagents_pubmed.py b/examples/smolagents_pubmed.py
@@ -13,7 +13,7 @@
 import os
 
 from mcp import StdioServerParameters
-from smolagents import CodeAgent, HfApiModel
+from smolagents import CodeAgent, HfApiModel  # type: ignore
 
 from mcpadapt.core import MCPAdapt
 from mcpadapt.smolagents_adapter import SmolAgentsAdapter

diff --git a/pyproject.toml b/pyproject.toml
@@ -33,11 +33,15 @@ test = [
     "pytest>=8.3.4",
     "mcpadapt[langchain]",
     "mcpadapt[smolagents]",
-    "mcpadapt[crewai]"
+    "mcpadapt[crewai]",
+    "mcpadapt[google-genai]"
 ]
 crewai = [
     "crewai>=0.108.0",
 ]
+google-genai = [
+    "google-genai>=1.2.0",
+]
 
 [tool.hatch.version]
 path = "src/mcpadapt/__init__.py"

diff --git a/src/echo.py b/src/echo.py
@@ -3,13 +3,14 @@
 """
 
 from mcp.server.fastmcp import FastMCP
+from pydantic import Field
 
 # Create server
 mcp = FastMCP("Echo Server")
 
 
 @mcp.tool()
-def echo_tool(text: str) -> str:
+def echo_tool(text: str = Field(description="The text to echo")) -> str:
     """Echo the input text
 
     Args:

diff --git a/src/mcpadapt/core.py b/src/mcpadapt/core.py
@@ -13,8 +13,8 @@
 
 import mcp
 from mcp import ClientSession, StdioServerParameters
-from mcp.client.stdio import stdio_client
 from mcp.client.sse import sse_client
+from mcp.client.stdio import stdio_client
 
 
 class ToolAdapter(ABC):

diff --git a/src/mcpadapt/google_genai_adapter.py b/src/mcpadapt/google_genai_adapter.py
@@ -0,0 +1,100 @@
+"""This module implements the Google GenAI adapter.
+
+Example Usage:
+>>> with MCPAdapt(StdioServerParameters(command="uv", args=["run", "src/echo.py"]), GoogleGenAIAdapter()) as tools:
+>>>     print(tools)
+"""
+
+import logging
+from typing import Any, Callable, Coroutine
+
+import jsonref  # type: ignore
+import mcp
+from google.genai import types  # type: ignore
+
+from mcpadapt.core import ToolAdapter
+
+logger = logging.getLogger(__name__)
+
+
+class GoogleGenAIAdapter(ToolAdapter):
+    """Adapter for the `google.genai` package.
+
+    Note that the `google.genai` package do not support async tools at this time so we
+    write only the adapt method.
+    """
+
+    def adapt(
+        self,
+        func: Callable[[dict | None], mcp.types.CallToolResult],
+        mcp_tool: mcp.types.Tool,
+    ) -> tuple[
+        types.Tool, tuple[str, Callable[[dict | None], mcp.types.CallToolResult]]
+    ]:
+        # make sure jsonref are resolved
+        input_schema = {
+            k: v
+            for k, v in jsonref.replace_refs(mcp_tool.inputSchema).items()
+            if k != "$defs"
+        }
+
+        return (
+            types.Tool(
+                function_declarations=[
+                    {
+                        "name": mcp_tool.name,
+                        "description": mcp_tool.description,
+                        "parameters": input_schema,
+                    }
+                ],
+            ),
+            (mcp_tool.name, func),
+        )
+
+    def async_adapt(
+        self,
+        func: Callable[[dict | None], Coroutine[Any, Any, mcp.types.CallToolResult]],
+        mcp_tool: mcp.types.Tool,
+    ) -> tuple[
+        types.Tool,
+        tuple[
+            str, Callable[[dict | None], Coroutine[Any, Any, mcp.types.CallToolResult]]
+        ],
+    ]:
+        # make sure jsonref are resolved
+        input_schema = {
+            k: v
+            for k, v in jsonref.replace_refs(mcp_tool.inputSchema).items()
+            if k != "$defs"
+        }
+
+        return (
+            types.Tool(
+                function_declarations=[
+                    {
+                        "name": mcp_tool.name,
+                        "description": mcp_tool.description,
+                        "parameters": input_schema,
+                    }
+                ],
+            ),
+            (mcp_tool.name, func),
+        )
+
+
+if __name__ == "__main__":
+    import os
+
+    from mcp import StdioServerParameters
+
+    from mcpadapt.core import MCPAdapt
+
+    with MCPAdapt(
+        StdioServerParameters(
+            command="uvx",
+            args=["--quiet", "[email protected]"],
+            env={"UV_PYTHON": "3.12", **os.environ},
+        ),
+        GoogleGenAIAdapter(),
+    ) as tools:
+        print(tools[0][1].args[-1])