# Galdo

> See how your company actually works. Galdo learns how your best people work, shares that know-how with your team and AI agents, and shows you what's ready to automate. It keeps the decisions, exceptions, and lessons behind that work, and how they change over time. People and AI agents ask it questions and get answers with a reference to the source. For agents, the same memory is a REST API, SDKs, and an MCP server. Benchmarked publicly on LongMemEval-S: 85.2% on the official LongMemEval judge. US-hosted. Free tier: 1,000 memory writes + 10,000 searches per month. No credit card.

Most of how a company works lives in a few people's heads and in Slack threads, ticket comments, and email. Galdo learns how that work actually gets done by observing it as it happens, through Galdo Capture, a lightweight browser extension you install for the people you choose: the people whose judgement you want to keep. It runs only on the sites an admin allows and only after each person agrees; employees can see when it's recording and pause it any time. It never logs keystrokes, reads the clipboard or takes screenshots, never records passwords or payment fields, and text typed into fields is redacted on the device and cut to 200 characters. From that work it pulls out the decisions, exceptions, people, dates, and the steps those people follow, each with a reference to where it came from. When a newer decision replaces an older one, the old one is marked superseded and ranks lower. It isn't deleted, so you can still ask what a rule used to be, what replaced it, and when.

People ask in Slack through Company Brain. Agents ask through the API or MCP and get the same memory. You can also write to it directly: POST /v1/memories to add, POST /v1/search to read back. Retrieval is hybrid: meaning, wording, extracted facts, entities, and time are searched together and fused into one ranking. That's why we score 85.2% on the official LongMemEval judge (gpt-4o-mini) on LongMemEval-S while pure-vector approaches plateau lower.

Galdo is independent of your agent's generation model. Keep using your existing model and framework while Galdo handles memory storage and retrieval. Self-hosted deployment is available on Enterprise: memory, the dashboard, the API and AI run on your servers with your own AI provider keys or a local model; with a local model it can run air-gapped. The Capture extension connects to hosted Galdo today.

Every page on getgaldo.com also serves a Markdown representation of itself: send `Accept: text/markdown` to any page URL and you get the prose without the layout.

## When to use Galdo

- [Handovers](https://getgaldo.com/use-cases/handovers): someone changes roles or leaves, and the next person needs to know why things are set up the way they are. They ask, and get the thread or ticket where it was decided.
- [New hires](https://getgaldo.com/use-cases/onboarding): learn how things are actually done, including the exceptions nobody wrote down, without waiting for the one person who knows.
- [Questions about what changed, and when](https://getgaldo.com/docs#api-search): "what changed since last quarter", "how did this work before the reorg". Dates and order are kept; a replaced memory is marked superseded and ranks lower instead of being deleted.
- [Procedures learned by watching the work](https://getgaldo.com/product): the Galdo Capture browser extension runs on the sites an admin allows, after each person agrees, and turns work sessions into step-by-step procedures with their branches and exceptions. Typed text is redacted; passwords, payment fields, and screenshots are never recorded.
- [Team memory inside Slack](https://getgaldo.com/brain): Company Brain learns from the public channels you invite it to and answers with links back to the exact messages.
- [Long-term memory for AI agents](https://getgaldo.com/for-agents): give an agent the team's memory so a rule that was replaced ranks below the one that replaced it, and the agent recalls what was said days or weeks ago, not just what fits in the context window. Write with POST /v1/memories, read back with POST /v1/search. Connect an agent over MCP and limit it to the containers it needs.
- [Cited answers over ingested documents](https://getgaldo.com/docs#api-documents): you need an answer that carries its source. Search results return the memory, its score, and a reference to the document it came from: a citation, not a vibe.
- [Cross-session user preference recall](https://getgaldo.com/docs#api-profile): the agent should stop re-asking things the user already told it. POST /v1/profile returns a prompt-ready block of what is known about one user.
- [Memory inside an existing agent framework](https://getgaldo.com/integrations): LangChain, LangGraph, Vercel AI SDK, AutoGen, CrewAI, PydanticAI, Semantic Kernel, LlamaIndex, Mastra, or MCP — Galdo slots in beside the framework rather than replacing it.
- [Answers on your own site](https://getgaldo.com/widget): one script tag turns your docs into a question box that answers with numbered sources.
- [People — one memory container per person](https://getgaldo.com/people): contact details, important dates, what they told you, and reminders with a due date. POST /v1/people, POST /v1/reminders, GET /v1/reminders/upcoming; a cited per-person summary at GET /v1/people/{slug}/summary.

## When not to use Galdo

- Not a vector-database primitive. If you want to own chunking, embedding models, index parameters, and raw ANN queries, use pgvector, Qdrant, or Pinecone directly. Galdo makes those decisions for you on purpose.
- Not a general search engine. Galdo only ever returns what was written into your workspace. It does not crawl the web and has no world knowledge of its own.
- Not a document store or CMS. Retrieval returns atomic facts with provenance, not the original files back. Keep the files where they already live.
- Not a system of record. Galdo is durable and event-sourced, but your primary database should stay primary — treat Galdo as a derived, rebuildable index of what matters.
- Not a chat model. Galdo does not generate the reply; it supplies the context your model generates from.
- Not a document generator. Galdo doesn't write handover reports or onboarding docs. It answers questions from what your tools already hold, with the source attached.

## Developer resources

- [Galdo API documentation](https://getgaldo.com/docs): quickstart, full REST reference, SDK guide, integrations, and versioning policy. Base URL https://api.mnemohq.com.
- [Galdo OpenAPI 3.1 spec](https://getgaldo.com/openapi.json): the machine-readable contract for every endpoint. Import it into a client generator or an agent tool loader.
- [Galdo CLI](https://www.npmjs.com/package/getmnemo-cli): `npm install -g getmnemo-cli` — add, search, and inspect memories from a terminal or a CI job.
- [Galdo TypeScript SDK](https://www.npmjs.com/package/getmnemo): `npm install getmnemo` — zero runtime dependencies, works on Node 18+, Bun, Deno, browsers, and Cloudflare Workers.
- [Galdo Python SDK](https://pypi.org/project/getmnemo/): legacy and incompatible with the current API — version 0.1.x sends request shapes the API rejects, so don't install it. From Python, call the REST API directly (the docs show httpx samples).
- [Galdo MCP server](https://www.npmjs.com/package/getmnemo-mcp): `npx -y getmnemo-mcp` for a local stdio server, or connect to the hosted remote MCP over Streamable HTTP transport with OAuth at https://mcp.mnemohq.com/mcp. Exposes memory_search, memory_add, memory_get, memory_update, memory_delete, and memory_list as MCP tools for Claude Desktop, Cursor, Windsurf, VS Code, and Zed. The local stdio server needs GETMNEMO_API_KEY and GETMNEMO_CONTAINER_TAG.
- [Galdo LangGraph package](https://www.npmjs.com/package/getmnemo-langgraph): `npm install getmnemo-langgraph` — a LangGraph JS store (BaseStore) plus remember / recall tools.
- [Galdo Vercel AI SDK package](https://www.npmjs.com/package/getmnemo-vercel-ai): `npm install getmnemo-vercel-ai` — two drop-in tools, memorySearch and memoryAdd, for streamText and generateText. Supports AI SDK 4.x (peer ai ^4.0.0).
- [Galdo Anthropic SDK package](https://www.npmjs.com/package/getmnemo-anthropic): `npm install getmnemo-anthropic` — Galdo as a memory tool with prompt caching and extended thinking wired up.
- [Galdo Mastra package](https://www.npmjs.com/package/getmnemo-mastra): `npm install getmnemo-mastra` — a Galdo-backed memory for Mastra agents: rememberMessage() persists each turn, remember() recalls context before generation. Supports Mastra 0.4.x (peer @mastra/core ^0.4.0).
- [Galdo dashboard](https://app.mnemohq.com): create a workspace, mint and rotate API keys, watch usage, configure connectors and widget tokens.
- [Galdo API versioning and deprecation policy](https://getgaldo.com/docs#api-versioning): v1 is URL-versioned; breaking changes only ever ship in a new version path; deprecations are announced in the changelog at least six months before sunset, with `Deprecation` and `Sunset` headers on every affected response.

## Authentication

- [Get a free Galdo API key](https://app.mnemohq.com/signup?utm_source=marketing&utm_medium=site_cta): 1K memory writes + 10K searches/month, no credit card.
- [Authentication reference](https://getgaldo.com/docs#auth): every direct REST request sends `Authorization: Bearer <api key>`; the key identifies the workspace, and the legacy `x-workspace-id` header is optional and ignored for API keys. Keys are workspace-scoped, hashed at rest, revocable, and rotatable with a 24-hour grace window — issue keys from the dashboard. There is no anonymous tier.
- [OAuth 2.0 & MCP](https://getgaldo.com/docs#oauth): a separate, live OAuth 2.0 authorization server for MCP clients (issuer https://api.mnemohq.com/v1/mcp/oauth, RFC 8414 metadata at https://api.mnemohq.com/.well-known/oauth-authorization-server). authorization_code + refresh_token grants, PKCE S256 required, dynamic client registration (RFC 7591). Used today by MCP clients (Claude, Cowork) connecting to the hosted MCP.

## Getting Started

- [Quickstart](https://getgaldo.com/docs#quickstart): 5-minute setup with TypeScript, Python, or cURL
- [Retrieval playground](https://getgaldo.com/playground): Recorded LongMemEval-S retrieval results
- [For AI agents](https://getgaldo.com/for-agents): Copy-paste tool schemas, MCP install, IDE rules
- [Contact](https://getgaldo.com/contact): support, sales, security disclosure, and partnership channels

## API Reference

- [OpenAPI 3.1 spec](https://getgaldo.com/openapi.json): Machine-readable full API specification
- [POST /v1/memories](https://getgaldo.com/docs#api-memories): Write a batch of memories (`items[]` plus a scope); returns the stored memories and a write receipt
- [POST /v1/documents](https://getgaldo.com/docs#api-documents): Async ingestion of transcripts or long docs
- [POST /v1/search](https://getgaldo.com/docs#api-search): Hybrid retrieval (`q` plus a scope) across all strategies, fused; answers with ranked `results`
- [POST /v1/profile](https://getgaldo.com/docs#api-profile): Prompt-ready context block for the current user
- [Errors and rate limits](https://getgaldo.com/docs#api-errors): Error bodies, RateLimit-* headers, and Retry-After on per-minute 429s; the per-second 429 carries error.code RATE_LIMIT_EXCEEDED
- [People and reminders](https://getgaldo.com/docs#api-people): /v1/people and /v1/reminders — scopes people:*, reminders:*
- Feature-flagged surfaces answer 503 with code FEATURE_DISABLED (never 404) until enabled for a workspace

## Integrations

- [All integrations](https://getgaldo.com/integrations): 8 frameworks with code examples
- [LangChain](https://getgaldo.com/integrations/langchain): Decorated tool functions (Python)
- [LangGraph](https://getgaldo.com/integrations/langgraph): Graph nodes with recall + store
- [Vercel AI SDK](https://getgaldo.com/integrations/vercel-ai-sdk): Typed Zod tool definitions (TypeScript)
- [AutoGen](https://getgaldo.com/integrations/autogen): Multi-agent shared memory
- [CrewAI](https://getgaldo.com/integrations/crewai): Crew-level memory tools
- [PydanticAI](https://getgaldo.com/integrations/pydantic-ai): Type-safe agents with RunContext
- [Semantic Kernel](https://getgaldo.com/integrations/semantic-kernel): C# kernel plugin you define over the REST API (no NuGet package)
- [LlamaIndex](https://getgaldo.com/integrations/llamaindex): RAG + user memory hybrid via a custom retriever over the REST API (no adapter package)
- [MCP server](https://getgaldo.com/for-agents#mcp): Install in Claude Desktop, Cursor, Windsurf, VS Code, Zed
- [IDE rules](https://getgaldo.com/for-agents#ide-rules): .cursorrules, CLAUDE.md, .windsurfrules, AGENTS.md

## Why Galdo

- [Benchmarks](https://getgaldo.com/benchmarks): Full per-category LongMemEval breakdown — no cherry-picking
- [Product](https://getgaldo.com/product): How the hybrid retrieval pipeline works

## Trust & Security

- [Trust center](https://getgaldo.com/trust): Security covenants, compliance, data handling
- [Single sign-on](https://getgaldo.com/docs#sso): SAML 2.0 or OIDC sign-in on Team and Enterprise; Require SSO and SCIM provisioning on Enterprise
- [About](https://getgaldo.com/about): Why Galdo exists
- [Privacy policy](https://getgaldo.com/privacy): What we collect, sub-processors, retention, your rights
- [Terms of service](https://getgaldo.com/terms): The agreement covering API use

## Optional

- [Blog](https://getgaldo.com/blog): Engineering deep-dives on retrieval architecture
- [Changelog](https://getgaldo.com/changelog): Release notes, and where deprecations are announced
- [Sitemap](https://getgaldo.com/sitemap.xml): Every URL on this site
- [llms-full.txt](https://getgaldo.com/llms-full.txt): Single-file concatenated docs for one-shot LLM ingestion