Honcho MCP server for AI agents and assistants

Securely connect your AI agents and chatbots (Claude, ChatGPT, Cursor, etc) with Honcho MCP or direct API to store and retrieve memories, search and summarize context, update agent state, and manage persona profiles through natural language.

Honcho logoHoncho
Api Key

Honcho is a memory, context, and theory-of-mind infrastructure for stateful AI agents. It provides durable agent memory and contextual tooling to keep conversations coherent.

16 Tools

Try Honcho now

Type what you want done — sign in and watch it run live in the Tool Router playground.

TOOL ROUTER PLAYGROUND
Honcho
Try asking
TOOLS

Supported Tools

Every Honcho action and event your agent gets out of the box.

Chat With Peer

Run usage-bearing agentic search and reasoning over a peer's learned representation to answer a question.

Create Conclusions

Store a batch of 1-100 explicit conclusions about peers, optionally tied to sessions.

Create Messages

Add a batch of 1-100 attributed messages to a Honcho session.

Delete Session

Permanently delete one known session and its session-scoped data.

Get Message

Return one message by its exact ID within a session.

Get or Create Peer

Return a peer by ID within a workspace, creating it with the supplied metadata and configuration when absent.

Get or Create Session

Return a session by ID, or create it with initial peers, metadata, and configuration when absent.

Get or Create Workspace

Return a workspace by ID, or create it with metadata and configuration when absent.

Get Peer Representation

Return a curated subset of conclusions representing a peer.

List Conclusions

Return one page of stored conclusions in a workspace; use Search Conclusions for semantic retrieval.

List Messages

Return one page of messages in a session; use Get Message for exact-ID retrieval.

List Peers

Return one page of peers in a workspace.

List Sessions

Return one page of sessions in a workspace.

List Workspaces

Return one page of Honcho workspaces visible to the connected admin key.

Search Conclusions

Semantically search stored conclusions in a workspace from a specified observer peer's perspective about a specified observed peer.

Search Messages

Semantically search messages at workspace, peer, or session scope.

SETUP GUIDE

Connect Honcho MCP Tool with your Agent

1

Install Composio

typescript
npm install @composio/core ai @ai-sdk/mcp @ai-sdk/openai
Install the Composio SDK and your agent framework
2

Create a session with MCP enabled

typescript
import { Composio } from "@composio/core";

const composio = new Composio();
const { mcp } = await composio.create("your-user-id", {
  toolkits: ["honcho"],
  mcp: true,
});
Create a session scoped to Honcho and read its MCP URL and headers
3

Connect your agent to the MCP server

typescript
import { createMCPClient } from "@ai-sdk/mcp";
import { openai } from "@ai-sdk/openai";
import { generateText, stepCountIs } from "ai";

const client = await createMCPClient({
  transport: { type: "http", url: mcp.url, headers: mcp.headers },
});

const { text } = await generateText({
  model: openai("gpt-5.6-sol"),
  tools: await client.tools(),
  prompt: "Retrieve agent memory for customer session",
  stopWhen: stepCountIs(10),
});

console.log(text);
await client.close();
Pass the session's MCP URL and headers to your agent and run a Honcho request
SETUP GUIDE

Connect Honcho API Tool with your Agent

1

Install Composio

typescript
npm install @composio/core @composio/openai openai
Install the Composio SDK, the OpenAI provider, and the OpenAI SDK
2

Create a Composio session

typescript
import OpenAI from "openai";
import { Composio } from "@composio/core";
import { OpenAIResponsesProvider } from "@composio/openai";

const composio = new Composio({ provider: new OpenAIResponsesProvider() });
const client = new OpenAI();

const session = await composio.create("your-user-id", { toolkits: ["honcho"] });
const tools = await session.tools();
Initialize Composio with the OpenAI Responses provider and create a session scoped to Honcho
3

Run Honcho tools with your agent

typescript
let response = await client.responses.create({
  model: "gpt-5.6-sol",
  tools,
  input: [{ role: "user", content: "Retrieve agent memory for customer session" }],
});

while (response.output.some((o) => o.type === "function_call")) {
  const outputs = await composio.provider.handleToolCalls(session, response.output);
  response = await client.responses.create({
    model: "gpt-5.6-sol",
    tools,
    previous_response_id: response.id,
    input: outputs,
  });
}

console.log(response.output_text);
Send a request, execute the Honcho tool calls through the session, and print the final answer

Why Use Composio?

AI Native Honcho Integration

  • Supports both Honcho MCP and direct API based integrations
  • Structured, LLM-friendly schemas for reliable tool execution
  • Rich coverage for reading, writing, and querying your Honcho data

Managed Auth

  • Built-in API key handling with secure storage
  • Central place to manage, scope, and revoke Honcho access
  • Per user and per environment credentials instead of hard-coded keys

Agent Optimized Design

  • Tools are tuned using real error and success rates to improve reliability over time
  • Comprehensive execution logs so you always know what ran, when, and on whose behalf

Enterprise Grade Security

  • Fine-grained RBAC so you control which agents and users can access Honcho
  • Scoped, least privilege access to Honcho resources
  • Full audit trail of agent actions to support review and compliance

Rolling this out across your team?

Give your team centralized access control across every framework with Composio’s MCP Gateway.

EXPLORE MCP GATEWAY
FAQ

Frequently asked questions

Start with Honcho.It takes 30 seconds.

Managed auth, hosted MCP servers, and every Honcho tool your agent needs.Free to start.

Start building