Context7
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
Openinsurance Wiki
Overview
Description from the maker (original English)
Open, source-cited knowledge base of Belgian insurance products: search, compare, verify, overlaps.
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
- UsageiVery new↓ 19/wk · ★ –
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 on your computer
- Transport: stdio
- Category: Search & AI memory
- You need to fill in: INSURANCE_WIKI_REPO
Install
Pick the AI app you use, then copy the settings.
Before you install
- Basic checks: 1 of 1 passed
- Runs on your computer with your user’s permissions (files, network, apps).
- You fill in yourself:
INSURANCE_WIKI_REPO
You need
- PyPIPython’s uv installed (for the uvx command)
Which app do you use?
Pick your app above. We remember it, so next time the button says “Install in …”.
Open Claude Desktop → Settings → Developer → Edit Config, and paste this into claude_desktop_config.json
{
"mcpServers": {
"openinsurance-wiki": {
"command": "uvx",
"args": [
"openinsurance-wiki-mcp"
],
"env": {
"INSURANCE_WIKI_REPO": "your-value"
}
}
}
}Run this in your terminal
claude mcp add openinsurance-wiki --env INSURANCE_WIKI_REPO=your-value -- uvx openinsurance-wiki-mcpFill in the empty values before running it.
Or copy the settings yourself
Paste into .cursor/mcp.json in your project, or ~/.cursor/mcp.json
{
"mcpServers": {
"openinsurance-wiki": {
"command": "uvx",
"args": [
"openinsurance-wiki-mcp"
],
"env": {
"INSURANCE_WIKI_REPO": "your-value"
}
}
}
}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": {
"openinsurance-wiki": {
"type": "stdio",
"command": "uvx",
"args": [
"openinsurance-wiki-mcp"
],
"env": {
"INSURANCE_WIKI_REPO": "your-value"
}
}
}
}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.
This one runs on your computer, and ChatGPT can only connect to servers on the internet. Pick another app.
Your choice stays on this device in a cookie; no account needed.
Values you fill in
- Path to a local clone of github.com/sluyasu/OpenInsurance (the wiki dataset lives in the repo, not in the package)
These settings are generated from the maker’s registry entry. If the README says otherwise, follow the README.
What it can do
Runs on your computer; the tool list appears in your AI app after you install it.
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 9, 2026
- ✓ Pass
Maker matches the repo
The registry name was verified with the GitHub account sluyasu, which owns the repo
- … 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 applicable
Endpoint responds
This one runs on your computer; there is no internet endpoint
- – Not applicable
Sign-in with OAuth
Runs on your computer and uses local settings instead
- … Not checked yet
No hidden instructions in tool descriptions
Runs on your computer; we can only read tool lists from internet endpoints
Compared with others in Search & AI memoryi
- More stars than 0% of the other 5727 servers in this category
- Published to the registry more recently than 21% of the other 5727 servers in this category
- Basic checks equal to or better than 100% of the other 5727 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 Openinsurance Wiki 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?
You need to fill in: INSURANCE_WIKI_REPO
Does it run on my computer or in the cloud?
It runs on your computer. Your AI app starts it when needed, and data does not pass through the maker’s servers (unless it calls an online service itself).
Is it still maintained?
The GitHub repo last changed –, and the latest version (0.2.0) 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. You also need Python (uv) on your computer.
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:↓ Downloads per weeki★ GitHub starsiThree pillars: reviews · checks · usageiUpdated = latest version published to the registryi
Codebase Memory
Codebase knowledge graph for AI agents — 162 languages, sub-ms queries, 99% fewer tokens.
Runs on your computer
Exa
Connect AI agents to Exa for web search, content fetching, and multi-step research.
Runs in the cloud✓ exa.ai
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.
openinsurance-wiki
A brain for a country's insurance market. A self-sufficient, open-source, country-agnostic framework that
turns a nation's public insurance documents into a rich, interconnected, source-cited knowledge base that any
AI agent can read.
Read it live: [sluyasu.github.io/OpenInsurance](https://sluyasu.github.io/OpenInsurance/) - every page in this repo, browsable and searchable, no install.
Not a chatbot. Not a RAG black box. A transparent, reproducible knowledge graph: the repo contains the whole chain - it finds insurers' public general-conditions PDFs, downloads them, and turns each one into a faithful Markdown page that preserves the maximum of what the PDF actually says, with a citation back to the source - all cross-linked into a navigable graph of products, insurers, branches, regulations and concepts.
As far as we know, this is the only open-source, machine-readable, source-cited database of insurance products (the closest equivalents are commercial and closed). Point it at any country: the taxonomy is data, not code, and adding a country is a documented recipe (_meta/BOOTSTRAP-COUNTRY.md).
The dataset covers four countries - Belgium, France, Luxembourg and Switzerland - for a total of 39 insurers and 1,189 product pages (auto, home, health, liability, travel, legal protection, ...), each page cited to its source document:
| Country | Insurers | Product pages | Branch pages | State |
|---|---|---|---|---|
Belgium (be) | 24 | 269 | 17 | Reference country: the only complete hand-authored layer - a branch page for every populated branch, 3 regulation pages, a country glossary |
France (fr) | 10 | 714 | 24 | Largest by volume; the enumerated market is far from exhausted |
Luxembourg (lu) | 4 | 194 | 15 | Core resident insurers ingested |
Switzerland (ch) | 1 | 12 | 0 | A first vertical slice, nothing more |
The recipe was proven on Belgium first and has since been run three more times, which is what turned "country-agnostic" from a design claim into a tested one. Live counts are the generated coverage table in AGENTS.md, rebuilt from the data on every index run.
Use it in 2 minutes - no API key needed
The dataset ships in the repo, already built: 1,189 product pages across four countries, insurer pages, glossary, plus the structured JSON behind them. You only need an LLM key to *re-extract from scratch*, never to *use* it.
1. Read it. Online at sluyasu.github.io/OpenInsurance, or open the cloned repo as an Obsidian vault and the [[wikilinks]] become a navigable graph. (github.com itself does not render [[wikilinks]] as links - the site or the vault is the comfortable way.)
2. Plug it into an agent (MCP). The MCP server is keyless and read-only:
git clone https://github.com/sluyasu/OpenInsurance.gitcd OpenInsurance python3 -m venv .venv && .venv/bin/pip install "mcp[cli]" pyyaml
Then register it with any MCP client, e.g. Claude Code:
claude mcp add insurance-wiki -- "$(pwd)/.venv/bin/python" "$(pwd)/mcp/insurance_wiki_mcp.py"(Or take the released server from PyPI - uvx openinsurance-wiki-mcp with INSURANCE_WIKI_REPO pointing at the clone; the in-repo server above is always the one matching the committed dataset.)
You get search, get_product, get_coverage (only what's relevant to one question, with verbatim quotes), compare_products, find_overlap (candidate duplicate cover when combining two policies), verify_claim (verbatim evidence for a fact-check), get_branch_overview, ... See mcp/README.md.
3. Take the raw data. data/ /extracted/ holds one structured JSON per source document, validated against schema/; data/ /index.json is the flat index (cc = be, fr, lu, ch). AGENTS.md is a generated manifest (note types, counts, per-page path / source_url / freshness) so a file-reading agent can navigate without guessing.
Why an MCP server (and not a chatbot, a RAG stack or a REST API)
The goal is that any AI agent can answer insurance questions from documents it can cite. That constraint picks the architecture:
Why MCP. The Model Context Protocol is the standard socket between AI assistants and data: one server, and Claude, ChatGPT, Cursor or your own agent plugs in with three lines of config instead of a custom integration. This server is keyless (no account, no API key, no quota), read-only, and needs zero hosting: the dataset is the repo itself, so the data travels with a git clone and works offline. When the wiki is re-extracted, git pull is the upgrade path.
Why not a RAG chatbot. A chatbot is a single interface; a knowledge base should serve many (a broker's comparison tool, a compliance check, a market-mapping agent). RAG adds an embedding index that is a black box: you cannot diff it, review it in a PR, or reproduce it, and its retrieval errors are invisible. Here the retrieval layer is deterministic matching over reviewed, committed files: the same query returns the same documents every time, and every answer carries the source PDF and page numbers. The LLM stays where it belongs, on the client side, reasoning over exact excerpts.
Why not a REST API. An API means a server running 24/7, uptime, keys, versioning, and one bespoke integration per consumer, for a dataset that changes a few times a year. MCP gives the same programmatic access at the cost of a local process.
How it works, in four stages:
- Sources (
sources/): committed YAML saying where each insurer's public PDFs live. - Frozen extraction (
data/): each PDF turned once into structured JSON and cited Markdown, by a prompt that is itself committed. Nothing is generated at query time. - Deterministic MCP server (
mcp/): 10 read-only tools over those files. No LLM inside, no network, no state. Same input, same output. - A reasoning client: the agent on top (Claude, a broker chatbot, a script) does the semantic work, quoting what the tools return.
The trust boundary is explicit: everything below stage 4 is reproducible and auditable. Hallucination risk is confined to the client, and the tool responses are shaped to keep that client honest: a grounding contract and a front-loaded citation line in every single-product response, refusal of ambiguous product names (with the candidates listed) instead of silent guessing, and a verify_claim tool so an agent can fact-check its own draft against the document before answering. See the response discipline notes in the server docs.
How fast. The server reads every file once and serves from memory: warm latencies run 0.01 to about 3 ms per tool on this dataset (measured, reproducible: mcp/README.md). In a real chatbot the time a user feels is the LLM's own inference, not these tools.
Why this exists
Insurance products are documented in dense PDFs scattered across dozens of insurer websites. There is no neutral, machine-readable, navigable map of what actually exists in a national market. This project builds one - as a public good, and in a form an AI agent can plug into.
It also plugs into a market that is standardizing around it: EU regulation 2017/1469 gives every non-life product a standardized summary (the IPID), EIOPA actively promotes product comparison and switching, and the open insurance agenda (OPIN, the EU FIDA proposal) pushes for machine-readable access to insurance data. This project is the missing *public documents* layer of that picture: what the products actually say, in the open.
Four things make it different:
- Self-sufficient & reproducible. Clone it, add your own LLM key, run
make all. It scrapes, downloads and extracts from scratch. No hidden datasets - every input is committed, every output is regenerable. - Transparent extraction. The exact prompt sent to the LLM is a file in this repo (
extraction-agent/), not buried in code. You can read precisely what the model was asked, and run the identical extraction with your own model (Claude, Gemini, GPT, or a local model). - Grounded & cited. Every product page traces back to the source PDF and cites page numbers. Quotes are verified against the raw text. If it isn't in the document, it isn't on the page.
- Scoped. A page is a contractual or pre-contractual document of a specific insurance product - nothing else. Insurers' download pages mix in company statutes, fund reports and promo riders; those are refused at three gates (a recorded
out_of_scopemarker in the sources, the extraction agent's own verdict, and a CI-blocking check). See CONTRIBUTING.
What's in the wiki
Per country (wiki/ /, e.g. wiki/be/):
| Folder | What | How it's made |
|---|---|---|
products/ / | One rich page per insurance product (general conditions / IPID) | Generated from the PDFs |
insurers/ | One page per insurer, aggregating its products | Generated |
branches/ | Overview of each line of insurance (every populated branch has one; make validate lists any gap) | Hand-authored |
regulations/ | The regulator and key laws (FSMA, mandatory RC auto, cat-nat...) | Hand-authored |
glossary/ | Country-specific terms (bonus-malus, franchise, Branche 21/23...) | Hand-authored |
Generated and hand-authored pages live in separate folders and never collide: you fix a fact by editing the extraction data and rebuilding, never by editing a generated page.
The generated layer exists for all four countries; the hand-authored layer is uneven and deliberately not hidden. Belgium has branch, regulation and glossary pages; France and Luxembourg have branch pages and one regulation page each; Switzerland has neither yet. make validate lists every populated branch that still lacks an overview page. Universal concepts that apply to every country live in wiki/universal-glossary/.
Every page is Obsidian-compatible Markdown with YAML frontmatter and [[wikilinks]].
Reproduce it from scratch
This is the only path that needs an LLM key (the extraction step). Scraping and download use a free stack (httpx + Playwright).
git clone https://github.com/sluyasu/OpenInsurance.gitcd OpenInsurance make setup # deps + playwright chromium (no paid scraping dependency) cp .env.example .env # set LLM_PROVIDER + your API key (any provider)
Reproduce a slice end-to-end:
make download COUNTRY=be INSURER= # fetch the public PDFs make extract COUNTRY=be INSURER= # PDFs -> rich Markdown + JSON (uses YOUR model) make build COUNTRY=be # assemble the wiki m
Only the beginning is shown; read the rest in the repo