agentify-toolkit 0.18.2__tar.gz → 0.19.0__tar.gz

{agentify_toolkit-0.18.2 → agentify_toolkit-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentify_toolkit
-Version: 0.18.2
+Version: 0.19.0
 Summary: Python Toolkit for Declarative AI Agent Development
 Author-email: Lewis Sheridan <lewis@backplane.dev>
 License:                                  Apache License
@@ -142,7 +142,7 @@ Dynamic: license-file
 
 ![Agentify Toolkit Logo](https://raw.githubusercontent.com/backplane-cloud/agentify-toolkit/main/agentify-logo-lg.png)
 
-![agent](https://raw.githubusercontent.com/backplane-cloud/agentify-toolkit/main/agent.png)
+![agent](https://raw.githubusercontent.com/backplane-cloud/agentify-toolkit/main/cli.png)
 
 Agentify is a lightweight, declarative-first toolkit for prototyping AI agents. It lets you define agents as YAML specs and test them rapidly from the CLI or Python, without committing to a framework or model provider.
 

{agentify_toolkit-0.18.2 → agentify_toolkit-0.19.0}/README.md

@@ -9,7 +9,7 @@
 
 ![Agentify Toolkit Logo](https://raw.githubusercontent.com/backplane-cloud/agentify-toolkit/main/agentify-logo-lg.png)
 
-![agent](https://raw.githubusercontent.com/backplane-cloud/agentify-toolkit/main/agent.png)
+![agent](https://raw.githubusercontent.com/backplane-cloud/agentify-toolkit/main/cli.png)
 
 Agentify is a lightweight, declarative-first toolkit for prototyping AI agents. It lets you define agents as YAML specs and test them rapidly from the CLI or Python, without committing to a framework or model provider.
 

{agentify_toolkit-0.18.2 → agentify_toolkit-0.19.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentify_toolkit"
-version = "0.18.2"
+version = "0.19.0"
 description = "Python Toolkit for Declarative AI Agent Development"
 readme = "README.md"
 requires-python = ">=3.10"

agentify_toolkit-0.18.2/src/agentify/tool.py → agentify_toolkit-0.19.0/src/agentify/_tool.py

@@ -132,7 +132,7 @@ def create_tool(spec: dict) -> Tool:
     
     # Create the Tool object
     tool = Tool(
-        name=spec["name"],
+        name=f"local.{spec['name']}",
         type=spec.get("type" or "remote"),
         description=spec.get("description", ""),
         vendor=spec.get("vendor", ""),

{agentify_toolkit-0.18.2 → agentify_toolkit-0.19.0}/src/agentify/agent.py

@@ -10,6 +10,10 @@ from .specs import load_tool_spec
 from .tool import create_tool
 from pathlib import Path
 
+# Import MCP Client
+# from agentify.mcp_client import MCPClient
+from agentify.mcp.client import MCPClientHTTP
+
 
 @dataclass
 class Agent:
@@ -23,6 +27,9 @@ class Agent:
     tool_names: list = field(default_factory=list)
     tools: dict = field(default_factory=dict)
 
+    # mcp_client: Optional["MCPClientHTTP"] = None
+    mcp_clients: list[MCPClientHTTP] = field(default_factory=list)
+
     agent_file: Path | None = None
     _tools_loaded: bool = field(default=False, init=False)
 
@@ -59,7 +66,7 @@ class Agent:
                 raise FileNotFoundError(f"Tool '{tool_name}' not found at {tool_file}")
 
             spec = load_tool_spec(tool_file)  # your YAML loader
-            tool = create_tool(spec)          # your tool factory
+            tool = create_tool(spec, tool_file)          # your tool factory
             self.tools[tool.name] = tool
 
         self._tools_loaded = True
@@ -101,35 +108,71 @@ class Agent:
 
 
 
-    def chat(agent: "Agent", debug: bool = False):
+    def chat(self, debug: bool = False):
         from rich.console import Console
         from rich.panel import Panel
         from rich.prompt import Prompt
         
-        # Load Tools
-        if agent.tool_names and not agent._tools_loaded:
-            agent.load_tools()
+        # Load Tools from local Files in tools/
+        if self.tool_names and not self._tools_loaded:
+            self.load_tools()
+
+        # MCP Tool loader
+        # if self.mcp_client:
+        #     self.mcp_client.initialize()
+        #     mcp_tools = self.mcp_client.list_tools()
+        #     mcp_tool_names = [t["name"] for t in mcp_tools]
+        # else:
+        #     mcp_tool_names = []
+
+        # MCP Tool loader v2
+
+        mcp_tools = []
+        mcp_tool_names = []
+
+        for client in self.mcp_clients:
+            client.initialize()
+            tools = client.list_tools()
+            # mcp_tools += tools
+            # mcp_tool_names += [t["name"] for t in tools]
+
+            for tool in tools:
+                namespaced_tool = tool.copy()
+
+                original_name = tool["name"]
+                namespaced_name = f"{client.name}.{original_name}"
+
+                namespaced_tool["name"] = namespaced_name
+
+                mcp_tools.append(namespaced_tool)
+                mcp_tool_names.append(namespaced_name)
 
         console = Console()
         
         # Print agent header
         console.print(Panel(
-            f"[bold cyan]{agent.name.upper()}[/bold cyan] [dim]{agent.version}[/dim]\n"
-            f"Role: {agent.description}\n"
-            f"Using [yellow]{agent.model_id}[/yellow] by {agent.provider}\n"
-            f"Tools: {agent.tool_names}",
+            f"[bold cyan]{self.name.upper()}[/bold cyan] [dim]{self.version}[/dim]\n"
+            f"Role: {self.description}\n"
+            f"Using [yellow]{self.model_id}[/yellow] by {self.provider}\n"
+            f"Agent Tools:      {self.tool_names}\n"
+            f"MCP Server Tools: {mcp_tool_names}",
             border_style="cyan"
         ))
 
         
-        # Precompute tool schemas if any
-        tool_schemas = [tool.to_schema() for tool in agent.tools.values()] if agent.tools else None
+        # Load Local Tool Schemas
+        tool_schemas = [tool.to_schema() for tool in self.tools.values()] if self.tools else None
         tools_block = ""
         if tool_schemas:
-            tools_block = "\n\nTOOLS:\n" + json.dumps(tool_schemas, indent=2)
+            tools_block = "\n\nLOCAL TOOLS:\n" + json.dumps(tool_schemas, indent=2)
+
+        # Load MCP Server Tools
+        if self.mcp_clients:
+            tools_block += "\n\nMCP TOOLS:\n" + json.dumps(mcp_tools, indent=2)        
+
 
         if debug:
-            console.print(tool_schemas)
+            console.print(tools_block)
 
         while True:
             prompt = Prompt.ask("\nEnter your prompt ('/exit' to quit)")
@@ -138,37 +181,47 @@ class Agent:
                 break
 
             # Add user input to conversation history
-            agent.conversation_history.append({"role": "user", "content": prompt})
+            self.conversation_history.append({"role": "user", "content": prompt})
 
             # Build full prompt from last N turns (e.g., last 6)
-            full_prompt = f"You must assume the role of {agent.role} when responding to these prompts:\n\n"
-            for turn in agent.conversation_history[-6:]:
+            full_prompt = f"You must assume the role of {self.role} when responding to these prompts:\n\n"
+            for turn in self.conversation_history[-6:]:
                 role = turn["role"]
                 content = turn["content"]
-                full_prompt += f"{role.upper()}: {content}\n"
+                full_prompt += f"Conversation History\n {role.upper()}: {content}\n"
 
             # Inject tool rules if tools exist
             if tool_schemas:
                 full_prompt += """
-                Rules for responding:
-
-                If you receive the command list tools, just list them in this pattern 1. <tool name>: <description>: <arguments>: local or remote as per type
-                1. When invoking a tool, respond with ONLY the raw JSON object. Do not wrap it in markdown, code fences, backticks, or any other formatting. Your response must be parseable directly as JSON. 
-                2. If the request can be answered naturally, respond in plain language.
-                3. When producing JSON, follow this exact format:
-                {
-                    "tool": "<tool>",
-                    "action": "<action>",
-                    "args": {...}
-                }
-                4. Never hallucinate tool use. If unsure whether a tool is needed, respond in plain language.
-                5. If asked what tools do you have, respond with the name and description of the tool.
+Respond to user requests naturally, but if a tool must be invoked, respond with ONLY raw JSON that is parseable, with no code fences, no extra labels, and no commentary.
+
+Rules:
+
+1. If the request is "list tools", respond with a numbered list of all tools in this pattern:
+   1. <tool name>: <description>: <arguments>: <type> (local or remote)
+
+2. When invoking a tool, respond ONLY with the JSON object in this exact format:
+{
+    "tool": "<tool name>",
+    "action": "<action name>",
+    "args": {...}
+}
+Do NOT wrap this in markdown, code blocks, backticks, or any extra text. The JSON must be parseable directly.
+
+3. Only use a tool if necessary. If no tool is needed, respond in plain language.
+
+4. Use the tool arguments exactly as defined in the schema.
+
+When a user requests a tool action, produce only the JSON object following the above format.
                 """
                 full_prompt += tools_block
+            
+            if debug:
+                console.print(full_prompt)
 
             # Send prompt to model
-            with console.status(f"[blue]{agent.name} is thinking...[/blue]", spinner="dots"):
-                response = agent.run(full_prompt)
+            with console.status(f"[green]{self.name.title()} is thinking...[/green]", spinner="dots"):
+                response = self.run(full_prompt)
 
             # Try parsing JSON (tool invocation)
             try:
@@ -180,43 +233,64 @@ class Agent:
                     cleaned = cleaned[4:]                                                      
                     cleaned = cleaned.strip()     
     
+                # LLM JSON RESPONSE
                 data = json.loads(cleaned)
                 tool_name = data.get("tool")
                 action_name = data.get("action")
                 args = data.get("args", {})
-                tool = agent.tools.get(tool_name)
-                if not tool:
-                    raise ValueError(f"Tool '{tool_name}' not found on agent")
-
-                # TOOL HANDLING
-                if tool.type == "internal":
-                    # INTERNAL TOOL
-                    console.print(f"[yellow]INVOKING INTERNAL TOOL: '{tool_name}' with args: {args}[/yellow]", style="bold black on yellow")
-                    tool_result = tool.invoke(args=args)
+                tool = self.tools.get(tool_name)
+
+                if tool:
+                    # TOOL HANDLING
+                    if tool.type == "internal":
+                        # Local Function Tool
+                        console.print(f"USING LOCAL TOOL: '{tool_name}' with args: {args}", style="white on green")
+                        tool_result = tool.invoke(args=args)
+                    else: 
+                        # Local API Tool
+                        console.print(f"USING LOCAL TOOL: '{tool_name}' action '{action_name}' with args: {args}", style="bold black on yellow")
+                        tool_result = tool.invoke(action_name, args)
                 else: 
-                    # REMOTE TOOL
-                    console.print(f"[yellow]INVOKING REMOTE TOOL: '{tool_name}' action '{action_name}' with args: {args}[/yellow]", style="bold black on yellow")
-                    tool_result = tool.invoke(action_name, args)    
+                    # Check MCP
+                    if tool_name in mcp_tool_names:
+                        # MCP SERVER TOOL
+                        console.print(f"USING MCP SERVER TOOL: '{tool_name}' with args: {args}", style="bold black on yellow")
+                        # tool_result = self.mcp_client.call_tool(tool_name, args)
+                        server_name, actual_tool = tool_name.split(".", 1)
+
+                        client = next(
+                            (c for c in self.mcp_clients if c.name == server_name),
+                            None
+                        )
+
+                        if not client:
+                            raise Exception(f"No MCP client found for server '{server_name}'")
+
+                        tool_result = client.call_tool(actual_tool, args)
+
+                        
+                # if not tool:
+                #     raise ValueError(f"Tool '{tool_name}' not found on agent")
 
                 # Minify JSON to avoid confusing model in next prompt
                 tool_result_str = json.dumps(tool_result, separators=(',', ':'))
 
                 # Add tool output to conversation history
-                agent.conversation_history.append({"role": "tool", "content": tool_result_str})
+                self.conversation_history.append({"role": "tool", "content": tool_result_str})
 
                 # Ask model to display tool output naturally
                 analysis_prompt = "Display the following tool data in natural language:\n" + tool_result_str
-                with console.status(f"[blue]{agent.name} is analysing tool data...[/blue]", spinner="dots"):
-                    response = agent.run(analysis_prompt)
+                with console.status(f"{self.name.title()} is analysing tool response...", spinner="dots"):
+                    response = self.run(analysis_prompt)
 
                 # Store agent response in history
-                agent.conversation_history.append({"role": "agent", "content": response})
+                self.conversation_history.append({"role": "agent", "content": response})
                 console.print(Panel.fit(response, title="Agent Response", border_style="green"))
 
 
             except (json.JSONDecodeError, ValueError):
                 # Treat as normal chat response
-                agent.conversation_history.append({"role": "agent", "content": response})
+                self.conversation_history.append({"role": "agent", "content": response})
                 console.print(Panel.fit(response, title="Agent Response", border_style="green"))
 
 def create_agents(specs: list) -> dict[str, Agent]:
@@ -244,8 +318,35 @@ def create_agent(spec: dict, provider: str = None, model: str = None, agent_file
     if api_key_env:
         api_key = os.getenv(api_key_env)
     
+    # Local Tools via tool.yaml or tool.yaml/tool.py within tools/
     tool_names = spec.get("tools")
 
-    agent = Agent(name=name, provider=provider, model_id=model_id, role=role, description=description, version=version, tool_names=tool_names, agent_file=agent_file)
+    # Load MCP Server clients
+    mcp_clients = []
+
+    mcp_spec = spec.get("mcp", {})
+    servers = mcp_spec.get("servers",[])
+
+    for server in servers:
+        server_name = server.get("name")
+        endpoint = server.get("endpoint")
+
+        if endpoint:
+            client = MCPClientHTTP(
+                name=server_name,
+                endpoint=endpoint
+            )
+            mcp_clients.append(client)
+    
+
+    # MCP Tools via MCP Server http://localhost:3333
+    # mcp_client = None
+    # mcp_spec = spec.get("mcp")
+    # if mcp_spec:
+    #     endpoint = mcp_spec.get("endpoint")
+    #     if endpoint:
+    #         mcp_client = MCPClientHTTP(endpoint)
+
+    agent = Agent(name=name, provider=provider, model_id=model_id, role=role, description=description, version=version, tool_names=tool_names, agent_file=agent_file, mcp_clients=mcp_clients)
 
     return agent

agentify_toolkit-0.19.0/src/agentify/cli.py

@@ -0,0 +1,57 @@
+import click
+from agentify import __version__
+from .commands import (
+    run_command,
+    serve_command,
+    deploy_command,
+    gateway_command,
+    runtime_group,
+    tool_group,
+    agent_group,
+    provider_group,
+    mcp_group, 
+    xmcp_group
+)
+
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+agentify_icon = """
+[white]             ██   [/white]
+[white] █████████████████[/white]    Command: [yellow]agentify provider add <provider_name>[/yellow] [green]# e.g. openai, xai, anthropic[/green]
+[white]░██   ░░███   ░░██[/white]    Command: [yellow]agentify agent new[/yellow] [green]# <-- Creates a new Agent[/green]
+[white]░██     ███     ██[/white]    [green]# Run Agent[/green]
+[white]░█████████████████[/white]    Command: [yellow]agentify run agent.yaml[/yellow]
+[white]░███████   ███████[/white]    [green]# Start MCP Server[/green]                
+[white]░█████████████████[/white]    Command: [yellow]agentify mcp start[/yellow]    
+[white]░░░██░░██░░██░░██ [/white]    [green]# Start Agent Runtime → Deploy Agent[/green]
+[white]  ░██ ░██ ░██ ░██ [/white]    Command: [yellow]agentify runtime start[/yellow] [green]→[/green] [yellow]agentify deploy agent.yaml[/yellow]
+[white]  ░░  ░░  ░░  ░░  [/white]
+"""
+
+
+console.print(Panel(agentify_icon, title=f"AGENTIFY TOOLKIT CLI v{__version__}", subtitle="Build, Run and deploy AI Agents declaratively", border_style="white"))
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="Agentify")
+def main():
+    """Agentify Toolkit CLI"""
+    pass
+
+# Attach lazy-loaded commands
+main.add_command(run_command)
+main.add_command(serve_command)
+main.add_command(deploy_command)
+main.add_command(gateway_command)
+main.add_command(runtime_group)
+main.add_command(tool_group)
+main.add_command(agent_group)
+main.add_command(provider_group)
+main.add_command(mcp_group)
+main.add_command(xmcp_group)
+
+# if __name__ == "__main__":
+#     main()

{agentify_toolkit-0.18.2 → agentify_toolkit-0.19.0}/src/agentify/commands/__init__.py

@@ -6,6 +6,8 @@ from .agent import agent_group
 from .provider import provider_group
 from .deploy import deploy_command
 from .gateway import gateway_command
+from ._mcp import xmcp_group
+from .mcp import mcp_group
 
 __all__ = [
     "run_command",
@@ -15,5 +17,7 @@ __all__ = [
     "deploy_command"
     "agent_group",
     "provider_group",
-    "gateway_command"
+    "gateway_command",
+    "mcp_group",
+    "xmcp_group"
 ]

agentify_toolkit-0.19.0/src/agentify/commands/_mcp.py

@@ -0,0 +1,183 @@
+# agentify/commands/mcp.py
+
+import click
+import requests
+from agentify.mcpserver.server import start_xmcp_server
+from rich.console import Console
+from rich.table import Table
+import json
+from rich.panel import Panel
+from rich.syntax import Syntax
+
+console = Console()
+
+
+@click.group(hidden=True)
+def xmcp_group():
+    """Manage Agentify Tool server"""
+    pass
+
+
+@xmcp_group.command("start")
+@click.option("--host", default="127.0.0.1", help="Host to bind MCP server")
+@click.option("--port", default=3333, help="Port to bind MCP server")
+def start(host: str, port: int):
+    """Start MCP Server"""
+    click.echo(f"Starting MCP server on {host}:{port}")
+    start_mcp_server(host=host, port=port)
+
+@xmcp_group.command("list")
+@click.option("--endpoint", default="http://127.0.0.1:3333", help="MCP server endpoint")
+def list_tools(endpoint: str):
+    """List tools exposed by the MCP server"""
+
+    url = f"{endpoint}/tools"
+
+    try:
+        response = requests.get(url, timeout=5)
+        response.raise_for_status()
+    except requests.RequestException as e:
+        console.print(f"[red]Error connecting to MCP server:[/red] {e}")
+        raise SystemExit(1)
+
+    data = response.json()
+    tools = data.get("tools", [])
+
+    if not tools:
+        console.print("[yellow]No tools found.[/yellow]")
+        return
+
+    table = Table(
+        title="MCP Tools",
+        show_header=True,
+        header_style="bold",
+        box=None,              # 👈 no borders
+        pad_edge=False
+    )
+
+    table.add_column("Tool Name", style="cyan", no_wrap=True)
+    table.add_column("Description", style="white")
+
+    for tool in tools:
+        table.add_row(
+            tool.get("name", ""),
+            tool.get("description", "") or ""
+        )
+
+    console.print(table)
+
+@xmcp_group.command("invoke")
+@click.argument("tool_name")
+@click.option(
+    "--args",
+    default="{}",
+    help="JSON string of arguments to pass to the tool",
+)
+@click.option(
+    "--endpoint",
+    default="http://127.0.0.1:3333",
+    help="MCP server endpoint",
+)
+def invoke_tool(tool_name: str, args: str, endpoint: str):
+    """Invoke a published tool"""
+    try:
+        arguments = json.loads(args)
+    except json.JSONDecodeError as e:
+        console.print(f"[red]Invalid JSON for --args:[/red] {e}")
+        raise SystemExit(1)
+
+    url = f"{endpoint}/tools/{tool_name}/invoke"
+
+    try:
+        response = requests.post(
+            url,
+            json={"arguments": arguments},
+            timeout=10,
+        )
+        response.raise_for_status()
+    except requests.HTTPError:
+        console.print(
+            f"[red]Tool invocation failed:[/red] {response.text}"
+        )
+        raise SystemExit(1)
+    except requests.RequestException as e:
+        console.print(f"[red]Error connecting to MCP server:[/red] {e}")
+        raise SystemExit(1)
+
+    data = response.json()
+    result = data.get("result")
+
+    # Pretty output
+    if isinstance(result, (dict, list)):
+        pretty = json.dumps(result, indent=2)
+        syntax = Syntax(pretty, "json", theme="ansi_dark", line_numbers=False)
+        console.print(Panel(syntax, title="Result"))
+    else:
+        console.print(Panel(str(result), title="Result"))
+
+@xmcp_group.command()
+@click.argument("tool_name")
+@click.option(
+    "--server", default="http://localhost:3333",
+    required=False,
+    help="MCP server URL (e.g. http://localhost:3333)",
+)
+def remove(tool_name: str, server: str):
+    """
+    Remove a tool from the MCP server.
+    """
+    url = f"{server.rstrip('/')}/tools/{tool_name}"
+
+    try:
+        response = requests.delete(url, timeout=10)
+    except requests.RequestException as e:
+        raise click.ClickException(f"Failed to connect to MCP server: {e}")
+
+    if response.status_code != 200:
+        try:
+            detail = response.json().get("detail")
+        except Exception:
+            detail = response.text
+        raise click.ClickException(
+            f"Failed to remove tool ({response.status_code}): {detail}"
+        )
+
+    click.echo(f"✓ Tool removed: {tool_name}")
+
+@xmcp_group.command("show")
+@click.argument("tool_name")
+@click.option("--server", default="http://localhost:3333", help="MCP server URL")
+def show_tool(tool_name, server):
+    """Show details for a single MCP tool."""
+    import requests
+    import sys
+    from rich.console import Console
+    from rich.table import Table
+    from rich.json import JSON
+
+    console = Console()
+
+    try:
+        resp = requests.get(f"{server}/tools/{tool_name}")
+        resp.raise_for_status()
+    except requests.HTTPError as e:
+        console.print(f"[red]Error:[/red] {e.response.text}")
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        sys.exit(1)
+
+    tool = resp.json()
+
+    table = Table(title=f"MCP Tool: {tool['name']}", show_header=False)
+    table.add_column("Field", style="bold")
+    table.add_column("Value")
+
+    table.add_row("Name", tool["name"])
+    table.add_row("Description", tool.get("description", ""))
+
+    console.print(table)
+
+    if "input_schema" in tool:
+        console.print("\n[bold]Input Schema[/bold]")
+        console.print(JSON.from_data(tool["input_schema"]))

{agentify_toolkit-0.18.2 → agentify_toolkit-0.19.0}/src/agentify/commands/agent.py

@@ -3,7 +3,7 @@ from pathlib import Path
 
 @click.group("agent")
 def agent_group():
-    """Create, List and Show agent YAML files"""
+    """Manage agent YAML definitions (create, list, show)"""
     pass
 
 

{agentify_toolkit-0.18.2 → agentify_toolkit-0.19.0}/src/agentify/commands/deploy.py

@@ -11,7 +11,7 @@ from pathlib import Path
 )
 def deploy_command(paths, server):
     """
-    Deploy agent YAML files to Agent Runtime server.
+    Deploy agents to the Agent Runtime server
 
     Examples:
       agentify deploy agent.yaml

{agentify_toolkit-0.18.2 → agentify_toolkit-0.19.0}/src/agentify/commands/gateway.py

@@ -3,7 +3,7 @@ import uvicorn
 
 @click.group(name="gateway")
 def gateway_command():
-    """Run the Agentify model gateway."""
+    """Start the Agentify model gateway service"""
     pass
 
 @gateway_command.command()