> ## Documentation Index
> Fetch the complete documentation index at: https://developer.eka.care/llms.txt
> Use this file to discover all available pages before exploring further.

# Custom MCP Client

> Integrate Eka.care MCP into your own application

## Overview

Want to build your own AI-powered healthcare application? You can integrate Eka.care MCP into any application that supports the Model Context Protocol standard.

> **📱 Build AI Health Apps**
>
> Create custom healthcare assistants

> **🤖 Automation Tools**
>
> Automate clinic workflows

> **🔧 Internal Tools**
>
> Custom admin dashboards

> **🌐 Web Services**
>
> API-powered AI services

***

## Quick Integration

### Using the MCP SDK

The easiest way is to use the official MCP SDK in your preferred language:

**Python**

```python theme={null}
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

# Create MCP client connection
server_params = StdioServerParameters(
    command="/path/to/.venv/bin/python",
    args=["-m", "eka_mcp_sdk.server"],
    env={
        "EKA_CLIENT_ID": "your_client_id",
        "EKA_CLIENT_SECRET": "your_client_secret",
        "EKA_API_KEY": "your_api_key"
    }
)

async with stdio_client(server_params) as (read, write):
    async with ClientSession(read, write) as session:
        # Initialize connection
        await session.initialize()
        
        # List available tools
        tools = await session.list_tools()
        print(f"Available tools: {[t.name for t in tools]}")
        
        # Call a tool
        result = await session.call_tool(
            "search_patients",
            arguments={"prefix": "Kumar"}
        )
        print(result)
```

**TypeScript**

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

const transport = new StdioClientTransport({
  command: "/path/to/.venv/bin/python",
  args: ["-m", "eka_mcp_sdk.server"],
  env: {
    EKA_CLIENT_ID: "your_client_id",
    EKA_CLIENT_SECRET: "your_client_secret",
    EKA_API_KEY: "your_api_key"
  }
});

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

await client.connect(transport);

// List available tools
const tools = await client.listTools();
console.log("Available tools:", tools.tools.map(t => t.name));

// Call a tool
const result = await client.callTool({
  name: "search_patients",
  arguments: { prefix: "Kumar" }
});
console.log(result);
```

**Go**

```go theme={null}
package main

import (
    "context"
    "fmt"
    "github.com/modelcontextprotocol/sdk-go/client"
)

func main() {
    // Create MCP client
    c := client.NewStdioClient(
        "/path/to/.venv/bin/python",
        []string{"-m", "eka_mcp_sdk.server"},
        map[string]string{
            "EKA_CLIENT_ID":     "your_client_id",
            "EKA_CLIENT_SECRET": "your_client_secret",
            "EKA_API_KEY":       "your_api_key",
        },
    )

    // Connect
    ctx := context.Background()
    if err := c.Connect(ctx); err != nil {
        panic(err)
    }
    defer c.Close()

    // List tools
    tools, err := c.ListTools(ctx)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Available tools: %+v\n", tools)

    // Call a tool
    result, err := c.CallTool(ctx, "search_patients", map[string]interface{}{
        "prefix": "Kumar",
    })
    if err != nil {
        panic(err)
    }
    fmt.Printf("Result: %+v\n", result)
}
```

***

## HTTP Integration

Prefer REST APIs? Deploy the MCP server with HTTP transport:

### Setup HTTP Server

```python server.py theme={null}
from fastmcp import FastMCP
from eka_mcp_sdk.tools.patient_tools import register_patient_tools
from eka_mcp_sdk.tools.appointment_tools import register_appointment_tools

# Create FastMCP instance
mcp = FastMCP("Eka.care MCP")

# Register tools
register_patient_tools(mcp)
register_appointment_tools(mcp)

# Run with HTTP transport
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(mcp.get_asgi_app(), host="0.0.0.0", port=8000)
```

### Call via HTTP

```bash theme={null}
# List available tools
curl http://localhost:8000/tools

# Call a tool
curl -X POST http://localhost:8000/call_tool \
  -H "Content-Type: application/json" \
  -d '{
    "name": "search_patients",
    "arguments": {"prefix": "Kumar"}
  }'
```

***

## Docker Deployment

Deploy as a containerized service:

```dockerfile Dockerfile theme={null}
FROM python:3.11-slim

WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install -r requirements.txt

# Copy MCP server code
COPY . .

# Install package
RUN pip install -e .

# Expose port
EXPOSE 8000

# Run server
CMD ["python", "-m", "eka_mcp_sdk.server"]
```

```yaml docker-compose.yml theme={null}
version: '3.8'

services:
  eka-mcp:
    build: .
    ports:
      - "8000:8000"
    environment:
      - EKA_CLIENT_ID=${EKA_CLIENT_ID}
      - EKA_CLIENT_SECRET=${EKA_CLIENT_SECRET}
      - EKA_API_KEY=${EKA_API_KEY}
      - EKA_API_BASE_URL=https://api.eka.care
    restart: unless-stopped
```

***

> [!NOTE]
>
> **Building Something Cool?** We'd love to hear about it!
>
> * Email us: [ekaconnect@eka.care](mailto:ekaconnect@eka.care)
> * Get featured in our showcase!


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.