# Build a Custom MCP Client

If you're building your own LLM application, you can connect to the Synapse
MCP server directly using the official MCP SDK. This gives your app access to
all 79 Synapse tools.

## SDKs

| Language | Package |
|----------|---------|
| TypeScript/JavaScript | `@modelcontextprotocol/sdk` |
| Python | `mcp` |

## TypeScript Example

### Install

```bash
npm install @modelcontextprotocol/sdk
```

### Connect via stdio

```typescript
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const transport = new StdioClientTransport({
  command: "npx",
  args: ["-y", "synapse-mcp-api@latest"],
  env: {
    SYNAPSE_MIND_KEY: process.env.SYNAPSE_MIND_KEY!,
    SYNAPSE_URL: "https://synapse.schaefer.zone",
  },
});

const client = new Client(
  { name: "my-app", version: "1.0.0" },
  { capabilities: {} }
);

await client.connect(transport);

// List all available tools
const { tools } = await client.listTools();
console.log(`Available tools: ${tools.length}`);
for (const tool of tools) {
  console.log(`- ${tool.name}: ${tool.description}`);
}

// Call a tool
const result = await client.callTool({
  name: "memory_recall",
  arguments: {},
});
console.log(result.content);

// Store a memory
await client.callTool({
  name: "memory_store",
  arguments: {
    category: "fact",
    key: "custom_client_test",
    content: "Built a custom MCP client",
    tags: ["test", "mcp"],
    priority: "normal",
  },
});

await client.close();
```

### Connect via HTTP/SSE (remote)

```typescript
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";

const transport = new SSEClientTransport(
  new URL("https://synapse-mcp.schaefer.zone/sse"),
  {
    requestInit: {
      headers: {
        Authorization: `Bearer ${process.env.SYNAPSE_MIND_KEY}`,
      },
    },
  }
);

const client = new Client(
  { name: "my-app", version: "1.0.0" },
  { capabilities: {} }
);

await client.connect(transport);
// ... use as above
```

## Python Example

### Install

```bash
pip install mcp
```

### Connect via stdio

```python
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

server_params = StdioServerParameters(
    command="npx",
    args=["-y", "synapse-mcp-api@latest"],
    env={
        "SYNAPSE_MIND_KEY": "mk_YOUR_KEY",
        "SYNAPSE_URL": "https://synapse.schaefer.zone",
    },
)

async with stdio_client(server_params) as (read, write):
    async with ClientSession(read, write) as session:
        await session.initialize()

        # List tools
        tools = await session.list_tools()
        print(f"Available tools: {len(tools.tools)}")

        # Call a tool
        result = await session.call_tool("memory_recall", {})
        print(result.content)

        # Store a memory
        await session.call_tool("memory_store", {
            "category": "fact",
            "key": "python_client_test",
            "content": "Built a Python MCP client",
            "tags": ["test", "mcp", "python"],
            "priority": "normal",
        })
```

## Tool Profiles

When connecting, you can request a specific tool profile via the
`Mcp-Tool-Profile` header (HTTP/SSE) or `MCP_PROFILE` env var (stdio):

```typescript
// stdio: set env var
env: {
  SYNAPSE_MIND_KEY: "mk_...",
  MCP_PROFILE: "minimal",  // 8 tools instead of 119
}

// HTTP/SSE: set header
requestInit: {
  headers: {
    Authorization: "Bearer mk_...",
    "Mcp-Tool-Profile": "minimal",
  },
}
```

## Error Handling

```typescript
try {
  const result = await client.callTool({ name: "memory_recall", arguments: {} });
  if (result.isError) {
    console.error("Tool error:", result.content);
  } else {
    console.log("Success:", result.content);
  }
} catch (err) {
  console.error("MCP error:", err);
}
```

## Use Cases

- **Custom AI assistants** — build your own agent with persistent memory
- **Workflow automation** — chain Synapse tools in custom workflows
- **Data pipelines** — extract memories, transform, load elsewhere
- **Monitoring dashboards** — display memory stats, chat history, tasks

## Next Steps

- [MCP Specification](https://spec.modelcontextprotocol.io)
- [Synapse MCP Repo](https://gitlab.com/schaefer-services/synapse-mcp)
- [API Overview](/docs/api/overview)