Integrating with Claude

1. The Anthropic Tools API — by registering Fastino as a custom tool within Claude workflows.

2. An MCP (Model Context Protocol) server — the same architecture used for ChatGPT, enabling Claude to query and update user data securely.

Overview

By connecting Claude with Fastino, your assistants gain:

• Personalized reasoning and adaptive tone.

• Continuous learning from user events and documents.

• Seamless context retrieval across sessions.

• GDPR-compliant, revocable user memory.

Claude becomes contextually aware of who the user is, how they act, and what they care about, without storing any private data directly.

Architecture

Flow Overview

1. Claude receives a user prompt.

2. It calls the registered Fastino tool (or MCP endpoint).

3. The tool queries Fastino for personalized data (/query or /chunks).

4. Fastino returns relevant snippets, summaries, or answers.

5. Claude incorporates these into its next model output.

Prerequisites

• A Fastino API key

• Access to Claude Tools API or MCP integration (Anthropic developer access)

• A registered user in Fastino (/register)

• Python 3.9+ or Node.js 18+ runtime for proxy setup

Example: Claude Tools Integration (Python)

Use Anthropic’s Tools API to define Fastino as an external retriever.

from anthropic import Anthropic, messages
import requests

FASTINO_API = "https://api.fastino.ai"
FASTINO_KEY = "sk_live_123"
HEADERS = {"Authorization": f"x-api-key: {FASTINO_KEY}", "Content-Type": "application/json"}

anthropic = Anthropic(api_key="sk-claude-xyz")

def retrieve_user_context(user_id, query):
    payload = {
        "user_id": user_id,
        "conversation": [{"role": "user", "content": query}],
        "top_k": 3
    }
    r = requests.post(f"{FASTINO_API}/chunks", json=payload, headers=HEADERS)
    results = r.json().get("results", [])
    context = "\n".join([res["excerpt"] for res in results])
    return context

tools = [
    {
        "name": "fastino_retrieve",
        "description": "Retrieve user context and relevant memory snippets from Fastino.",
        "input_schema": {
            "type": "object",
            "properties": {
                "user_id": {"type": "string"},
                "query": {"type": "string"}
            },
            "required": ["user_id", "query"]
        }
    }
]

def fastino_tool_runner(tool_input):
    user_id = tool_input["user_id"]
    query = tool_input["query"]
    return {"context": retrieve_user_context(user_id, query)}

resp = anthropic.messages.create(
    model="claude-3-5-sonnet-2025",
    max_tokens=500,
    tools=tools,
    messages=[
        {"role": "user", "content": "When does Ash prefer to schedule meetings?"},
        {"role": "system", "content": "Use Fastino tools when relevant."}
    ],
    tool_choice={"type": "auto"}
)

print(resp)

Example: MCP Integration with Claude

Claude can also connect to Fastino through your existing Fastino MCP server (the same one used for ChatGPT).

In this setup:

• The MCP manifest defines Fastino’s tools (retrieve_relevant_chunks, search_or_ask, update_memory).

• Claude calls these tools dynamically when reasoning about the user.

Manifest Example

{
  "name": "Fastino Personalization API",
  "description": "Provides personalized memory and retrieval tools for Claude.",
  "tools": [
    {"name": "retrieve_relevant_chunks"},
    {"name": "search_or_ask"},
    {"name": "update_memory"}
  ]
}

Once the manifest is linked in your Claude MCP configuration, the model can query user context exactly as it does with ChatGPT.

Example: Retrieving Context in Claude

Response

Claude can use this directly in its reasoning loop, personalizing responses and tone dynamically.

Updating User Memory from Claude

If a user says “Shift my focus hours to 1–4 PM,” Claude can send:

POST /ingest
{
  "user_id": "usr_42af7c",
  "source": "claude_tool",
  "documents": [
    {
      "doc_id": "update_focus_20251027",
      "kind": "note",
      "title": "Focus hours updated",
      "content": "User prefers focus time from 1–4 PM PT."
    }
  ]
}

This ensures Fastino’s world model stays synchronized across both Claude and other connected agents.

Use Cases

Authentication

Fastino requests must include:

Authorization: x-api-key: <FASTINO_API_KEY>

Claude’s Tool or MCP runtime uses your configured Fastino key securely via environment variable:

Error Handling

Fastino’s responses are fully JSON-compliant and safe to pass through Anthropic’s structured tool interface.

Example error:

If a user is not yet registered, Claude can call /register automatically to initialize them.

Best Practices

• Use short summaries (/summary) for Claude’s context window (<1500 chars).

• Retrieve context before each response for real-time personalization.

• Log new signals to Fastino after every session.

• Combine search_or_ask with Claude’s tool reasoning for multi-turn personalization.

• Use different keys for sandbox and live modes.

• Respect privacy: don’t send PII in query text.

Example End-to-End Flow

1. Claude user logs in → workspace identifies user_id.

2. Claude retrieves personalization data from Fastino.

3. Claude generates response using adaptive tone and behavior.

4. User updates preferences → sent back to Fastino via /ingest.

5. Memory propagates across connected tools (ChatGPT, Pioneer, etc.).

Summary

Integrating Fastino with Claude gives you a unified, compliant, and adaptive personalization layer across Anthropic’s ecosystem.
Claude becomes capable of true continuity and behavioral understanding — leveraging Fastino’s user world models to recall context, predict behavior, and personalize every conversation.

Next, continue to Personalization Use Cases → Overview to explore how these integrations power advanced agent capabilities.