Infrastructure Reference

The memory your agents are missing.

Kimono exposes your private relationship graph to every AI working on your behalf — via REST API, MCP server, and CLI. This is what makes Kimono infrastructure, not just a tool. Scroll down for the AI agent integration guide.

REST API MCP Server CLI / SDK Node.js JWT Auth
Infrastructure Duality
People generate the graph.
Machines consume it.
People
"Who do I know at Stripe?"
Human-facing UI. Natural language queries. Relationship context on demand.
Machines
"GET /paths?to=stripe.com"
API, MCP, and CLI. Your agents consume the graph the same way you do.

Query your graph programmatically.

All endpoints are scoped to authenticated users. Base URL: https://kimono.polsia.app/api

GET /warmpath
Find the warmest path between two contacts in your graph. Uses Dijkstra's algorithm to find the path with the highest total connection strength. Returns the path nodes with contact details and edge context.
ParameterTypeDescription
fromreqintegerSource contact ID (your owner contact, or a specific contact)
toreqintegerTarget contact ID — the person you're trying to reach
# Find warm path from your identity to Marcus Reyes
curl -H "Authorization: Bearer $KIMONO_TOKEN" "https://kimono.polsia.app/api/warmpath?from=1&to=42"

# Response — Dijkstra returns the warmest path
{
  "found": true,
  "path": [
    { "contactId": 1, "edgeStrength": null, "contact": { "name": "Alex Rivera", "company": "Meridian Ventures" }},
    { "contactId": 15, "edgeStrength": 5, "edgeContext": "ex-Stripe, co-invested in Tempo AI", "contact": { "name": "Jamie Chen", "company": "Tempo AI" }},
    { "contactId": 42, "edgeStrength": 4, "contact": { "name": "Marcus Reyes", "role": "Head of BD, Stripe" }}
  ],
  "hops": 2,
  "total_strength": 9
}

# No path found — 3 hops or more, disconnected graph
{ "found": false, "message": "No connection path found between these contacts" }
GET /contacts
List all contacts in your graph with optional search filtering by name, email, company, or role. Returns full contact records with connection metadata.
ParameterTypeDescription
searchstringSearch by name, email, company, or role. Case-insensitive substring match.
limitnumberResults per page. Default: 100. Max: 200.
offsetnumberPagination offset. Use with total for cursor-based pagination.
# List all contacts at Stripe
curl -H "Authorization: Bearer $KIMONO_TOKEN" "https://kimono.polsia.app/api/contacts?search=stripe&limit=20"

# Response
{
  "contacts": [
    { "id": 15, "name": "Jamie Chen", "email": "jamie@stripe.com", "company": "Stripe", "role": "VP Sales", "is_owner": false },
    { "id": 42, "name": "Marcus Reyes", "email": "marcus@stripe.com", "company": "Stripe", "role": "Head of BD", "is_owner": false }
  ],
  "total": 4
}
POST /connections
Add an edge between two contacts. Each edge stores connection strength (1–5) and optional context describing how you know the person. Kimono uses these edges to compute warm paths.
ParameterTypeDescription
contact_a_idreqintegerFirst contact ID
contact_b_idreqintegerSecond contact ID
strengthnumberConnection strength 1–5. Default: 3. Higher = warmer.
contextstringNatural language description of how you know them (e.g., "co-invested in Tempo AI", "ex-colleagues at Stripe")
# Connect two contacts
curl -X POST -H "Authorization: Bearer $KIMONO_TOKEN" "Content-Type: application/json" "https://kimono.polsia.app/api/connections" -d '{"contact_a_id":15,"contact_b_id":42,"strength":4,"context":"ex-colleagues at Stripe"}'

# Response — upsert semantics (update if exists)
{ "connection": { "id": 88, "contact_a_id": 15, "contact_b_id": 42, "strength": 4, "context": "ex-colleagues at Stripe" }}
GET /contacts/:id
Get a single contact with all their connections. Useful for building the contact detail view and for AI agents doing meeting prep.
curl -H "Authorization: Bearer $KIMONO_TOKEN" "https://kimono.polsia.app/api/contacts/42"

# Response — contact + all connected edges
{
  "contact": { "id": 42, "name": "Marcus Reyes", "email": "marcus@stripe.com", "company": "Stripe", "role": "Head of BD" },
  "connections": [
    { "connection_id": 88, "strength": 4, "context": "ex-colleagues at Stripe", "connected_name": "Jamie Chen" }
  ]
}

Plug your graph into any AI agent.

Kimono's MCP server exposes your relationship graph as a tool your AI assistant can call directly — no custom integrations required.

AI agents need relationship context.

Every AI tool you use starts from zero about your network. The MCP server fixes this — your agent gets warm paths, contact context, and relationship history on demand, within its existing workflow.

Configure it once. Every subsequent agent call has access.

Available Tools

P
get_warm_path
Find first/second-degree path to a person or company
C
list_contacts
List contacts filtered by company, role, or strength
I
get_intro_context
Get talking points and shared history for meeting prep
K
get_kimono_id
Retrieve scoped relationship ID for sharing
Architecture
Claude / GPT / Gemini
Your AI Agent
MCP Client
kimono-mcp
Kimono API
Your Graph
Installation
# Install the Kimono MCP server
npm install -g @kimono/mcp-server

# Add to your MCP client config
kimono auth --token $KIMONO_API_KEY

Query from the terminal.

Install the Kimono CLI and integrate relationship queries into your workflow, scripts, or existing tools.

Install

npm install -g @kimono/cli
kimono auth --login

Configuration

# ~/.config/kimono/config.json
{
  "api_key": "kim_your_key_here",
  "default_depth": 2,
  "format": "json"
}

Query Commands

kimono paths Find warm paths to a company or person
kimono paths --to "stripe.com"
kimono paths --to "marcus@stripe.com" --context "BD"

# Output
Warm path found (2 hops):
  You
  → Jamie Chen (ex-Stripe, co-invested in Tempo AI)
  → Marcus Reyes (Head of BD, Stripe)
Ask: Jamie Chen → Marcus Reyes
kimono contacts List your contacts
kimono contacts --company "stripe" --format "table"

# Output
NAME           ROLE                   STRENGTH
Sarah Chen     Head of Partnerships   0.85
Marcus Reyes   Head of BD             0.72
Jamie Chen     VP Sales               0.90
kimono warmpath Get full intro package
kimono warmpath "marcus@stripe.com" "partnership intro" --urgency medium

Integrate in Node.js

npm install @kimono/sdk
const { Kimono } = require('@kimono/sdk');

const client = new Kimono({ apiKey: process.env.KIMONO_API_KEY });

// Step 1: Find contact ID by email or company
const { contacts } = await client.contacts.list({ search: 'marcus@stripe.com' });
const target = contacts[0];

// Step 2: Get warm path — path[1] is the intro broker
const path = await client.warmpath.find({
  from: target.owner_id,
  to: target.id
});
if (path.found) {
  console.log(`Ask ${path.path[1].contact.name}`,
              `(${path.path[1].edgeContext}) to intro ${target.name}`);
}

Give your agents the relationship graph.

Every AI tool starts from zero about your network. Your agents can call the Kimono API directly — no MCP server required, just a fetch call and your token.

AI Agent Request Pattern

// In your agent prompt or webhook handler:
const target = "marcus@stripe.com";
const userId = req.user.id; // from auth session

// 1. Find the contact ID for the target email
const contactRes = await fetch(
  `https://kimono.polsia.app/api/contacts?search=${encodeURIComponent(target)}`,
  { headers: { "Authorization": `Bearer ${req.session.token}` }}
);
const { contacts } = await contactRes.json();
const targetContact = contacts[0];
if (!targetContact) return { message: "No contact found" };

// 2. Get your owner contact ID
const ownerRes = await fetch(
  `https://kimono.polsia.app/api/contacts?search=${encodeURIComponent(req.user.email)}`,
  { headers: { "Authorization": `Bearer ${req.session.token}` }}
);
const { contacts: [ownerContact] } = await ownerRes.json();

// 3. Find the warm path
const pathRes = await fetch(
  `https://kimono.polsia.app/api/warmpath?from=${ownerContact.id}&to=${targetContact.id}`,
  { headers: { "Authorization": `Bearer ${req.session.token}` }}
);
const path = await pathRes.json();

// 4. Return path to agent for intro drafting
if (path.found) {
  const middlePerson = path.path[1];
  return {
    warmPath: path.path,
    introSuggestion: `Ask ${middlePerson.contact.name} to introduce you to ${targetContact.name}`,
    context: middlePerson.edgeContext
  };
}

Meeting Prep Use Case

// When agent receives: "Prep me for my call with Marcus at Stripe"

// 1. Get Marcus's contact + connections
const detailRes = await fetch(
  `https://kimono.polsia.app/api/contacts/${targetId}`,
  { headers: { "Authorization": `Bearer ${token}` }}
);
const { contact, connections } = await detailRes.json();

// connections[0] tells you the intro context — include in prep
return {
  name: contact.name,
  company: contact.company,
  role: contact.role,
  introContext: connections[0]?.context, // e.g. "ex-colleagues at Stripe"
  howYouKnowThem: connections[0]?.connected_name, // e.g. "Jamie Chen"
  talkingPoints: ["Ask about Tempo AI's recent round", "Reference mutual connection Jamie Chen"]
};

Why the MCP Server Matters

Without the MCP server, every agent workflow needs custom API integration code. With it, you declare the connection once — and every agent call gets relationship context without additional implementation.

ApproachUse When
Direct APICustom agent, webhook handler, or server-side integration. Full control.
MCP ServerAgent runs via Polsia or Claude Desktop. Declarative config, zero custom code per call.
CLITerminal workflows, one-off scripts, or CI/CD pipelines. Human-readable output.

The Memory Problem

"Every AI tool you use starts from zero about your relationships."
The API doesn't just query your graph — it solves the context problem that makes every other AI tool useful only for things that don't matter.

Kimono is Plaid for PII — an infrastructure layer that makes your private relationship graph accessible to every machine that needs it, while keeping it private.

JWT Bearer token auth.

All API endpoints require a valid JWT in the Authorization header. Tokens are issued on login via POST /api/auth/login. Every request is scoped to the authenticated user — agents only see your graph.

Login to Get a Token

# Sign in — returns a JWT
curl -X POST https://kimono.polsia.app/api/auth/login -H "Content-Type: application/json" -d '{"email":"alex@meridian.vc","password":"..."}'

# Response
{
  "token": "eyJhbGciOiJIUzI1NiIs...",
  "user": { "id": 1, "email": "alex@meridian.vc", "name": "Alex Rivera" }
}

Using the Token

# Pass as Bearer token on every request
curl -H "Authorization: Bearer $KIMONO_TOKEN" https://kimono.polsia.app/api/warmpath?from=1&to=42

# Node.js example
const res = await fetch('/api/contacts', {
  headers: { "Authorization": `Bearer ${req.session.token}` }
});

Security Model

# Agents get least-privilege access
# - Only the authenticated user's graph is visible
# - No cross-user data access (even with token theft)
# - No PII exposed unless explicitly shared via Kimono ID

# Your token lives in sessionStorage / HTTP-only cookie
# Never embed in client-side JS or pass to third parties

Session vs API Token

Token TypeUse When
Session JWTBrowser-based app. HttpOnly cookie, auto-refresh on /api/auth/me.
API Token (Bearer)AI agent webhook, server-side script, CLI. Pass in Authorization header.

Register

# Create account
curl -X POST https://kimono.polsia.app/api/auth/register -H "Content-Type: application/json" -d '{"name":"Alex Rivera","email":"alex@meridian.vc","password":"..."}'
"You can export contacts.
You cannot export context."
Plaid for PII