Context7 Smithery AI Agent MCP Server

## n8n AI Agent as an MCP Service (Context7 Docs Example)

**What This Workflow Does:**
This n8n setup transforms a complex AI agent into a single, callable tool exposed over an MCP (Multi-Agent Collaboration Protocol) SSE (Server-Sent Events) endpoint. It allows external clients (like development environments, other AI agents, or custom applications) to leverage the power of an n8n-hosted AI agent with a simple natural language query.

**How It Works:**
1.  **`Context7 MCP Server Trigger` (This Workflow):** Creates a public SSE endpoint. Its path is kept long and random for basic security by obscurity. This trigger exposes the `call_context7_ai_agent` tool.
2.  **`call_context7_ai_agent` (Tool Workflow Node, This Workflow):** This node is the "tool" offered by the MCP server. When called by a client, it doesn't do the AI work itself; instead, it invokes a separate sub-workflow.
3.  **AI Agent Sub-Workflow (e.g., "Context7 Smithery AI Agent MCP Server" - ID: vqujIu65SFbZUz0n):** This is where the magic happens!
    *   It receives the `query` from the main workflow.
    *   A `Context7 AI Agent` node, powered by a model like Google Gemini, orchestrates the task.
    *   The agent uses connected tools:
        *   `context7-resolve-library-id`: To find the correct ID for a software library.
        *   `context7-get-library-docs`: To fetch documentation for that library.
    *   It uses `Simple Memory` (scoped by execution ID) to maintain conversational context if needed for multi-turn interactions (though this example is primarily single-shot).

**Why This Pattern is Useful & The Smithery Connection:**

*   **Simplifies Client-Side Logic:** Clients (like **Smithery's Roo code**, VS Code extensions, or other AI systems) don't need to manage complex multi-step reasoning, tool selection, or API calls to different services. They just call *one tool* (`call_context7_ai_agent`) with a plain language request (e.g., "What is flexbox in Tailwind CSS?").
*   **Reduces Client-Side Token Usage:** All the detailed system prompts, tool descriptions for the sub-tools (resolve-id, get-docs), and the actual execution of these tools happen *within n8n*. The client only sends a short query and receives the processed result. This is incredibly efficient, especially if the client is another LLM.
*   **Centralized Agent Capabilities:** You can update, enhance, or swap out models and tools within your n8n AI agent sub-workflow without needing to update any of the client applications that consume it.
*   **Ideal for Agentic Systems:** This pattern is a cornerstone of building robust **agentic systems**. By encapsulating specialized AI capabilities within n8n and exposing them as callable MCP tools:
    *   You can create a "team" of specialized n8n agents.
    *   A primary agent (in Smithery, or another n8n workflow) can delegate tasks to these specialized n8n agent-tools.
    *   It promotes modularity, reusability, and scalability in AI application development.
*   **Leverage n8n's Ecosystem:** Build your agent with n8n's visual interface, manage credentials securely, and easily integrate with hundreds of other services if your agent needs them.

**Client Configuration Example (for Roo Code/Cline):**
To connect to this n8n agent from a client like Roo code, you'd configure it with the MCP server details:
```json
"n8n-context7-agent": { // A descriptive name for your client
  "url": "https://YOUR_N8N_INSTANCE/mcp/YOUR_LONG_RANDOM_PATH/sse", // Path from MCP Server Trigger
  "alwaysAllow": [
    "call_context7_ai_agent" // Name of the Tool Workflow node
  ]
}