O

Open Index

Build Smarter Agents using Structured Context

AgentOpen Source

A structured context layer for agents: define doc_types, doc_schemas, entities and connectors to model a domain, then give agents a searchable, navigable context graph instead of a pile of markdown. Ships an explorer UI with search, map visualisation and analytics, an MCP server for read and write access (local or remote over HTTP, including agent write-back), hybrid keyword + semantic search, and pluggable storage (SQLite by default, OpenSearch at scale).

What is Open Index?

Open Index is an MIT-licensed, self-hosted structured context layer for AI agents. Instead of handing an agent a folder of prose, you model a domain as a 'brain' built from four primitives — doc_type (a concept you track, e.g. service, customer, issue), doc_schema (the fields for that type), entity (one instance, stored per its schema), and connector (an optional source you extract entities from). Every entity links to others through a related_to target plus a free-text relationship_edge_meaning that carries the edge semantics, so the result is a searchable context graph without running a graph database. Agents reach it through an MCP context layer that both reads and writes, so accumulated learnings go back into the same validated structure.

Key features

  • Four modelling primitives — doc_type, doc_schema, entity, connector — with entity-to-entity links carrying free-text edge meaning, giving a navigable graph without a separate graph database.
  • SQLite + FTS5 as the default backend for local and single-writer use, with semantic search up to roughly 10,000 entities.
  • OpenSearch backend for concurrent writers and deployments past ~10k entities, adding native fuzzy matching and k-NN semantic search.
  • MCP context layer over stdio via `open-index mcp`: reads through search_brain(), get_entity() and navigation_guidelines(); writes through put_entity(), put_entities() and create_doc_type(), all validated against the schema and storage policy.
  • `--read-only` flag on the MCP server to expose the brain to an agent without granting write access.
  • `open-index serve` publishes the same MCP tools over HTTP with bearer-token auth for remote agents, and `--brains` serves every brain under a directory from one process.
  • `open-index mcp-config` prints the connection block to paste straight into an agent's MCP config.
  • Explorer UI (`open-index ui`) with Explore, Map, Analytics and Jobs tabs, plus optional Python connectors under connectors/*.py that ingest entities from other MCP servers on a schedule.

Who it's for

  • Give a domain agent a navigable entity graph — services, customers, issues — instead of an unversioned pile of markdown that contradicts itself.
  • Let an agent write what it learned back into a schema-validated store, so accumulated context stays structured rather than drifting into free text.
  • Share one context store across several agents, moving from SQLite to OpenSearch at the point where a second agent needs to write.
  • Expose a brain to remote agents over HTTP with bearer-token auth, or in --read-only mode to agents you do not want writing back.
  • Keep the store fed automatically by scheduling connectors that pull entities from other MCP servers via `open-index ingest` / `open-index run`.

When not to use it

The default SQLite backend does a brute-force cosine scan for semantic search and is single-writer, so it tops out around 10,000 entities — past either line you have to stand up and operate OpenSearch yourself, and there is no hosted tier to fall back on because this is a self-hosted Python package only.

FAQ

How much does Open Index cost?

Nothing to license — it is MIT and self-hosted, installed with pip. There is no managed or hosted tier, so the only cost is the infrastructure you run it on, which for a local brain is a SQLite file on disk and for a larger one is an OpenSearch cluster you operate.

Does my data leave my machine?

By default a brain is a local directory of JSON entities indexed into SQLite, and the MCP server runs over stdio on the same machine. Remote access is opt-in: `open-index serve` exposes the MCP tools over HTTP and requires a bearer token.

How does my agent actually connect to it?

Run `open-index mcp` for a stdio MCP server, or `open-index serve` for HTTP. `open-index mcp-config` prints the ready-made connection block to paste into your agent's config. Add `--read-only` to either if the agent should read but not write.

What do I need installed?

Python — CI tests against 3.10 and 3.13 — plus pip extras for the parts you want: `[all]` for core, explorer UI and MCP server, or narrower extras `[serve]`, `[semantic]` and `[opensearch]`. Note that pytest silently skips the MCP and UI suites when those extras are missing.

Open SourceDeveloper ToolsAI InfrastructureKnowledge Graph
Submitted by Siddarth JainX ↗Launched September 12, 2026

Share this launch

Embed this badge

Featured on OrangeBot
<a href="https://orangebot.ai/product/open-index" target="_blank" rel="noopener noreferrer">
  <img src="https://orangebot.ai/api/badge/open-index.svg" alt="Featured on OrangeBot" width="200" height="54" />
</a>

Comments