Context7
by upstash
Feeds AI the latest docs for libraries and frameworks before it answers, so code it writes does not use outdated, removed functions.
Computer or cloud★ 64,224MITUpdated 3 days ago
Install
Kumbuka
Overview
Description from the maker (original English)
Governed, auditable knowledge your team curates for its AI assistants, self-hostable
PopNx MCP’s three pillars
These three are never merged into one score: opinions, measurements and popularity are different things.
- User voiceiNo reviews yetReviews open together with accounts in a later step
- Our basic checksi1 of 1 passedChecked from public information; code not scanned yet
- UsageiNot measured yet★ –
What you can do with it
We have not written a plain-language summary for this one yet. Below are the facts we read from the registry.
- Connection: Runs in the cloud
- Transport: Streamable HTTP
- Category: Search & AI memory
Install
Pick the AI app you use, then copy the settings.
Before you install
- Basic checks: 1 of 1 passed
- Runs on the maker’s server: what you ask it goes through their server.
- The registry lists no key to fill in.
You need
- Runs in the cloudNothing to install; it connects over the internet
Which app do you use?
Pick your app above. We remember it, so next time the button says “Install in …”.
Works in Claude on the web, desktop and mobile:
- Open Settings → Connectors
- Press Add custom connector
- Paste the address below and press Add
- If it asks you to sign in, sign in with the maker
https://mcp.kumbuka.ai/mcpRun this in your terminal
claude mcp add --transport http kumbuka https://mcp.kumbuka.ai/mcpOr copy the settings yourself
Paste into .cursor/mcp.json in your project, or ~/.cursor/mcp.json
{
"mcpServers": {
"kumbuka": {
"url": "https://mcp.kumbuka.ai/mcp"
}
}
}Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.
Or copy the settings yourself
Paste into .vscode/mcp.json in your project
{
"servers": {
"kumbuka": {
"type": "http",
"url": "https://mcp.kumbuka.ai/mcp"
}
}
}Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.
ChatGPT connects only to servers on the internet:
- Open ChatGPT on the web → Settings → Connectors (Apps)
- Press Create or Add (some plans need Developer mode under Advanced first)
- Paste the address below, give it a name and save
- If it asks you to sign in, sign in with the maker
https://mcp.kumbuka.ai/mcpMenu names can differ slightly by plan and over time.
Your choice stays on this device in a cookie; no account needed.
These settings are generated from the maker’s registry entry. If the README says otherwise, follow the README.
What it can do
We have not read this server’s tool list yet; we check endpoints in rotation.
Basic checksi
We check information anyone can see; we have not read the code. Checks that do not apply are left out of the count. · Checked Nov 6, 2026
- ✓ Pass
Maker matches the repo
The registry name was verified against the domain kumbuka.ai (the registry checks domain ownership)
- … Not checked yet
Still maintained
We have not read this repo from GitHub yet
- … Not checked yet
Has a licence
We have not read this repo from GitHub yet
- … Not checked yet
Endpoint responds
Not checked yet; we check endpoints in rotation
- … Not checked yet
Sign-in with OAuth
Not checked yet; we check endpoints in rotation
- … Not checked yet
No hidden instructions in tool descriptions
Not checked yet; we read the tool list when we check the endpoint
Compared with others in Search & AI memoryi
- More stars than 0% of the other 7234 servers in this category
- Published to the registry more recently than 21% of the other 7234 servers in this category
- Basic checks equal to or better than 100% of the other 7234 servers in this category
Compared with every active server in this category in the registry. Stars count only when the publisher owns the repo.
Common questions
Is Kumbuka safe?
It passed 1 of 1 applicable basic checks. We have not read the code. Before adding a key or token, see what access the server asks for and use a key with only the permissions you need.
What keys or codes does it need?
The registry does not list a required key, though some servers ask you to sign in on first use.
Does it run on my computer or in the cloud?
It runs in the maker’s cloud. Connect over the internet with nothing to install, but what you send passes through the maker’s servers.
Is it still maintained?
The GitHub repo last changed –, and the latest version (1.0.1) reached the registry 4 months ago.
Which apps can use it?
Apps that support MCP, such as Claude Desktop, Claude Code, Cursor and VS Code. It connects by URL, so apps that accept remote MCP servers work too, such as ChatGPT in developer mode.
What can I use instead?
In the same category: Context7, Codebase Memory, Exa
Alternatives
Servers in the same category from other makers, sorted by stars.
Reading a card:★ GitHub starsiThree pillars: reviews · checks · usageiUpdated = latest version published to the registryi
Codebase Memory
by DeusData
Codebase knowledge graph for AI agents — 162 languages, sub-ms queries, 99% fewer tokens.
Runs on your computer★ 48,148MITUpdated 20 days ago
Install
Exa
by exa-labs
Connect AI agents to Exa for web search, content fetching, and multi-step research.
Runs in the cloud★ 5,213MITUpdated 44 days ago
Install
README from the maker
Open the README
Copied from the maker’s repo as written. PopNx MCP has not reviewed or endorsed it. HTML, images and scripts are removed. Links lead off this site.
kumbuka
Services for teams that work with AI assistants and agents — curated rules, commissioned work, and the inventory of what is to be done, each held as individually addressable objects, each in a service of its own.
Status: pre-beta. kumbuka is in active development. The architecture and
data model are settled and the private-memory guarantee is a hard design
constraint, but the project is not yet a hardened, shipped product. Expect
rough edges and breaking changes.
*kumbuka* is Swahili — the imperative "remember!". The project lives at kumbuka.ai.
The problem: a result without a record
AI assistants are stateless between sessions, and the work they do leaves a result but rarely a record. A team using them pays twice.
It pays the context tax: the same rules are explained again in every new session — *"we use Postgres as the system of record"*, *"money is integer minor units, never floats"* — because the decisions, conventions and constraints that should shape the work live in people's heads and in scattered chat history.
And it loses the trail of the work itself. Once an assistant or an agent has done something, the questions that matter later are hard to answer: who asked for it, under which rule, what came back, and who accepted it. A session transcript ends with the session; a finished file does not say which request produced it.
What kumbuka is
kumbuka is a set of services that hold exactly those things — what a team has settled, the work it commissions and gets back, and what it still intends to do — as objects that are addressed one by one, read by assistants over the Model Context Protocol (MCP), and curated by the team.
| Service | What it holds |
|---|---|
| Memory | The curated rules a team has settled — decisions, conventions, constraints, definitions, open questions and status — typed, scoped, and read by the assistant at the start of the work. |
| Dispatch | Work commissioned and returned: one party states a task, another takes it up and answers, and the acceptance of the answer is an act of its own; the commission freezes when it is sent, so it stays readable later who asked what, who answered, and what was accepted. |
| Worklist | The inventory of what is to be done and in what order: items that are created, characterised, planned, claimed, worked and terminated, and that stay editable for their whole life. |
| Documents | The documents that say what currently holds. kumbuka-documents is not yet publicly available. |
Each service is built as a product of its own and published in its own repository. Every service has a complete REST interface. Dispatch and Worklist each also carry their own MCP endpoint; Memory has no MCP adapter of its own and is reached by assistants through the platform's MCP entry point (see Architecture).
kumbuka is deliberately not a document store or a RAG index, and it does not watch what people do. It holds *curated* content that someone wrote down and the team stands behind, not a copy of your docs or source, which stay in their own systems.
The private-memory guarantee
A member's private memory is theirs alone. It is reachable only by them,
only over their own authenticated MCP session. **No admin, no console screen,
and no team-facing API can read it.**
This is the backbone of the product, not a feature flag. It is enforced at the data-access layer — the privileged (admin/console) code paths have no route that can return private rows — not by a configuration toggle that could be flipped. Disabling a member suspends their account but leaves their private memory untouched and theirs.
See the Security & privacy guide for how this is structurally enforced.
Tenant separation
Each service keeps its own schema and its own database role in PostgreSQL. Tenants are separated by row-level security on the tenant axis: the policy fails closed, so a request that is not bound to a tenant sees no rows rather than all of them. The runtime role of a service owns nothing and holds only the privileges its migrations enumerate, so it cannot switch the policy off.
One sign-in for every service
Sign-in runs through [`cimd-proxy`](https://github.com/kumbuka-ai/cimd-proxy), the OAuth 2.1 authorization server in front of the identity provider. Outward it speaks Client ID Metadata Documents: an MCP client identifies itself by a URL it controls, so the endpoint URL is all a client needs — no client id and no client secret to copy around. Inward it federates the sign-in to Keycloak, which issues the token.
From outside, the platform is one resource with one audience. One sign-in yields one token, and that token is valid for every service behind the entry point. Each service validates the unchanged token itself; none relies on a predecessor having checked it.
Connect your assistant
kumbuka is reached by AI clients as a custom MCP connector. In claude.ai you add it under Settings → Connectors, sign in once through the OAuth flow, and your assistant can then call the services' tools on your behalf, including your own private memory scope.
Through the platform's entry point the tools are named _ — memory_query, dispatch_claim, worklist_create and so on — so one connector carries the tools of every service.
Architecture
The diagram shows the hosted deployment as it runs today. Caddy is the edge and validates no token. cimd-proxy is the authorization server, and Keycloak is the identity provider behind it. The platform is the entry point: a router that reads the service named in an address and forwards the call over REST to the service that owns it, together with the management core for scopes, teams and settings. Memory, Dispatch and Worklist each validate the token themselves and keep their own schema in one PostgreSQL instance. The ops console is the operator's own interface, reachable only from an IP allow-list.
flowchart TDC["AI assistant or agent (any MCP client)"] O["Operator browser"]
E["Caddy edge (validates no token)"]
X["cimd-proxy OAuth 2.1 authorization server (Client ID Metadata Documents)"] K["Keycloak (identity provider, issues the token)"]
R["platform router + management core"]
subgraph services["Domain services (each validates the token itself)"] M["Memory"] D["Dispatch"] W["Worklist"] end
OC["ops console (operator, IP allow-list)"] P[("PostgreSQL one schema and one role per service")]
C -- "1 · sign-in" --> E E -- "auth host" --> X X -- "federates sign-in" --> K C -- "2 · MCP or REST + bearer token" --> E E -- "/mcp, /api" --> R R -- "REST, token forwarded unchanged" --> M R -- "REST, token forwarded unchanged" --> D R -- "REST, token forwarded unchanged" --> W
O --> E E -- "ops host" --> OC
R --> P M --> P D --> P W --> P K --> P OC --> P
The router and the unified interface exist only in the enterprise edition. In a community installation there is no router, and the services are addressed directly.
Quickstart
There is no self-host package for the services today, and this README does not pretend otherwise. Each service repository documents how to build the service, run its full test suite, and configure it for your own database and identity provider. The suites need Docker; they start their own PostgreSQL (and, for Dispatch and Worklist, their own Keycloak) through Testcontainers.
kumbuka-memory— configuration and buildkumbuka-dispatch— configuration, build and testkumbuka-worklist— configuration, build and testcimd-proxy— quick start and configuration of the authorization server
The Docker Compose stack in kumbuka-server starts the management core with PostgreSQL, Keycloak and Caddy. The memory engine has left that repository, so the stack no longer serves memory on its own.
Repo map
| Repo | What it is |
|---|---|
kumbuka | This repo — the project front door and public documentation. |
kumbuka-memory | The memory service: curated entries, their scoping and authorship, and the typed relations between them. AGPL-3.0. |
kumbuka-dispatch | The dispatch service: commissioned work and its answer as durable, addressable objects. AGPL-3.0. |
kumbuka-worklist | The worklist service: what a scope intends to do, as items worked through a process. AGPL-3.0. |
kumbuka-documents | The documents service. Not yet publicly available. |
cimd-proxy | The OAuth 2.1 authorization server: Client ID Metadata Documents outward, federation to an existing OIDC provider such as Keycloak inward. Apache-2.0. |
kumbuka-server | The management core: scopes, teams, settings and the tenancy directory. AGPL-3.0. |
kumbuka-console | The Next.js admin console. AGPL-3.0. |
The router and the enterprise modules live in private repositories.
Documentation
The documentation site lives at [docs.kumbuka.ai](https://docs.kumbuka.ai) (English and German). It still describes the earlier memory-only stack in places; where it and this README disagree on which services exist, this README is current.
Editions and license
kumbuka is open core, and the line between the editions is a repository line: the repository boundary is the licence boundary.
- Community edition. The public service repositories (
kumbuka-memory,kumbuka-dispatch,kumbuka-worklist, together withkumbuka-serverandkumbuka-console) are open source under the GNU Affero General Public License v3.0 (AGPL-3.0), and each service is built as a complete product on its own.cimd-proxyis a standalone tool and is published under Apache-2.0. - Enterprise edition. Each service has a separate, closed enterprise module that is composed with its open core at build time. The enterprise edition adds and never alters: versioning and audit are the first things it adds. The router — the single entry point in front of all services — and the unified interface on top of it belong to the enterprise edition.
Because kumbuka is typically deployed as a network-accessible service, AGPL §13 applies: if you run a modified version and let users interact with it over a
Only the beginning is shown; read the rest in the repo