Mindola MCP server

Mindola turns a person's own material (writing, notes, documents, links) into a public AI page that answers questions from that material alone, with citations.

That public AI page is called a lens: one shareable link, like https://mindola.ai/me/your-name, where anyone can ask questions in chat or a live voice call. Every answer is grounded only in the owner's material and shows its sources. If the material does not cover a question, the lens says so honestly instead of guessing, and can hand the question to the real person.

This repository is the public documentation and examples for Mindola's hosted MCP server. The server is remote: there is nothing to install or run. You add one URL to your MCP client (Claude, Cursor, VS Code, Codex, ChatGPT), and your AI assistant can create and fill a lens for you in one conversation. The server itself runs inside the Mindola app, which is closed source; this repo holds the docs and example code.

Try a live lens right now, no account needed: mindola.ai/me/charles-darwin.

What problem Mindola solves

People publish knowledge that nobody reads. Your blog posts, documentation, course material, and notes sit in archives, and visitors are expected to dig through them. Most will not. They have one question and they want one answer.

A generic AI chatbot is not the fix. It answers from whatever it was trained on, so it confidently makes things up about you, your product, or your work. That is worse than no answer.

Mindola sits in between. It gives your material a front door: a page that answers questions from your knowledge base and nothing else, cites where each answer came from, and admits when it does not know. Visitors get answers instead of archives, and you get to see what they asked.

Why Mindola instead of building RAG yourself

Building retrieval-augmented generation (RAG) yourself is a real project. You need ingestion for every source type, chunking that respects document structure, embeddings, a vector store, retrieval tuning, grounding logic so the model stays inside your material, a citation UI, refusal behavior for out-of-scope questions, and then hosting, monitoring, and a front end. Add real-time voice and it roughly doubles.

Mindola gives you the finished product behind one link and one API. You provide the material; Mindola handles knowledge retrieval, grounded answers, citations, refusals, voice, the public page, and the inbox for unanswered questions. You can go from nothing to a working grounded AI page in one conversation with your coding assistant.

Building your own is still the right call in some situations. If you need full control over which models run, where your data lives, or how retrieval is ranked, or you want to embed the pipeline deep inside an existing product, roll your own. Mindola is for everyone who wants the outcome without owning the pipeline.

Core capabilities

• Grounded answers with citations. Every answer comes from the owner's material only, and shows its sources. Private material never leaks into citations.
• Honest refusals. Out-of-scope questions get a clear "I don't know" instead of a hallucinated answer.
• Live voice calls. Visitors can talk to a lens in real time, with barge-in (they can interrupt mid-sentence). Owners can use a cloned voice or a stock voice.
• Lead capture built in. Questions the lens cannot answer land in the owner's inbox with the visitor attached, so a lens doubles as light CRM.
• Optional payments. Owners can charge visitors through Stripe Connect, using their own Stripe account with per-lens pricing. Off by default.
• 10 app languages. The app UI supports English, Dutch, German, Spanish, French, Arabic, Japanese, Korean, Turkish, and Chinese.
• Many uses from one link. The same lens can answer for your website, your docs, or your coaching practice, depending on what you feed it.

Installation

The MCP server is hosted. There is nothing to run locally; you point your client at a URL.

Claude Code

claude mcp add --transport http mindola https://app.mindola.ai/mcp/lens

Cursor (~/.cursor/mcp.json or project .cursor/mcp.json)

{
  "mcpServers": {
    "mindola": {
      "url": "https://app.mindola.ai/mcp/lens"
    }
  }
}

Claude Desktop / claude.ai

Settings -> Connectors -> Add custom connector -> URL https://app.mindola.ai/mcp/lens.

For VS Code, Codex CLI, Windsurf, Gemini CLI, ChatGPT, and troubleshooting, see docs/installation.md. Ready-to-copy client configs live in examples/clients/.

Quick start

With your AI assistant

1. Connect the server using any snippet above.
2. Paste a prompt like this:

Create a Mindola lens for me. I'm a nutrition coach specializing in
plant-based diets for endurance athletes. I've been coaching for 8 years.
Use a warm tone. Ask me anything you need, then show me the profile
before you create it.

3. Your assistant drafts a profile (name, bio, expertise, facts, boundaries) and shows it to you. The tool's instructions require your assistant to get your explicit confirmation before creating anything, and to use only information you provided or confirmed in the conversation.
4. Confirm. The assistant calls create_digital_twin_lens and returns:
   • shareUrl: your public lens page, live immediately
   • claimUrl: open it and sign up (free) to make the lens yours
   • manageUrl, expiresAt, factCount, and suggestedPrompts

No account is needed to create. The lens starts out unclaimed: live at its share URL, expiring after 30 days if never claimed. While it is unclaimed, your assistant can keep adding knowledge to it with add_lens_knowledge. Once you claim it, changes go through the app or the authenticated developer API.

5. Keep going in the same conversation. Ask your assistant to add your articles or pages:

Add my last three blog posts to the lens, then check the ingestion
status and tell me when everything is ready.

The assistant calls add_lens_knowledge with the URLs, then polls get_lens_status until the knowledge counts show everything as ready. Open the share URL and ask your lens a question.

With the REST API

Create an API key in the Mindola app, then create a lens seeded with knowledge in one call:

curl -s https://app.mindola.ai/api/v1/lenses \
  -H "Authorization: Bearer mnd_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Product docs assistant",
    "greeting": "Hi, ask me anything about the product.",
    "knowledge": [
      { "type": "url", "content": "https://example.com/docs/getting-started", "title": "Getting started" },
      { "type": "text", "content": "Refunds are available within 30 days of purchase.", "title": "Refund policy" }
    ]
  }'

The response is 201 with { id, token, shareUrl, sourcesQueued }. Ingestion runs in the background; poll GET /api/v1/lenses/:id until the knowledge counts show ready. Full reference in docs/api.md.

20 real-world use cases

1. Coach: an ask-me-anything page that answers from your method and captures leads when a question needs the real you.
2. Open source maintainer: developer documentation that answers questions with citations instead of making readers search.
3. Course creator: a course assistant students can ask at 2 a.m., grounded in the syllabus and lessons.
4. Indie founder: a customer support AI for a small product, answering from your docs and changelog.
5. Job seeker: a CV that answers recruiters' questions about your experience, in chat or voice.
6. Small team: internal documentation behind one link that the whole team can ask.
7. Podcaster: a persona built from episode notes and transcripts that listeners can question between episodes.
8. Newsletter writer: an archive readers can query instead of scrolling through years of issues.
9. Conference speaker: a page attendees can keep asking after the talk ends, seeded with your slides and notes.
10. Consultant: an AI expert page that qualifies inbound leads before the first call.
11. Author: a book companion that discusses your ideas and cites the chapters they come from.
12. Agency: a services page that pre-answers scope, process, and pricing questions from your own material.
13. Teacher: a study helper grounded in class materials, so answers match what was actually taught.
14. Researcher: a page that answers questions about your papers and points to the exact source.
15. Product manager: a release-notes lens, so "did you ship X yet" answers itself.
16. Local business: a lens on your site that answers hours, services, and policy questions from your own pages.
17. HR team: an onboarding assistant that answers from the employee handbook instead of a shared drive.
18. Fitness trainer: paid Q&A through Stripe, where visitors pay to ask your lens directly.
19. Community manager: a rules and guidelines bot that answers moderation questions consistently.
20. Historical educator: a public-domain figure brought to life, like the Charles Darwin demo.

Ten of these are written out end to end in examples/use-cases/, each with a prompt to paste, the conversation to expect, and the final result.

Example prompts

Paste any of these into Claude, Codex, Cursor, or ChatGPT once the server is connected.

Create a Mindola lens for me. I'm a freelance UX designer with 10 years
of experience in fintech and healthcare. Interview me briefly to fill
the gaps, show me the profile, and only create it after I approve.

Read the README and docs folder of this repository, then create a
Mindola lens that answers questions about the project's docs.
Show me the proposed profile before creating anything.

Turn my CV into a Mindola lens that answers recruiters' questions.
Here is my CV: [paste CV]. Keep the tone professional and add a
boundary that it never discusses salary expectations.

Create a Mindola lens for my online course "Intro to Data Analysis".
It should act as a course assistant for students. I'll paste the
syllabus and lesson summaries next.

Add these three articles to my Mindola lens YOUR_LENS_TOKEN:
https://example.com/post-1
https://example.com/post-2
https://example.com/post-3

Check the status of my Mindola lens YOUR_LENS_TOKEN. Tell me how many
knowledge sources are ready, pending, or failed.

Create a Mindola lens for our startup's support. Use our FAQ page at
https://example.com/faq and the refund policy I paste below. Tone:
professional. Add suggested prompts about setup, billing, and refunds.

Create a Mindola lens in Dutch (locale nl) for my bakery. It should
answer questions about opening hours, allergens, and custom orders
from the text I provide.

One hundred more, organized by role and goal, in docs/prompts.md. For an industry-first view, examples/100-prompts.md holds 100 one-sentence prompts grouped by field, from customer support to online courses.

API overview

The REST developer API v1 lives at https://app.mindola.ai and authenticates with Authorization: Bearer mnd_<key>. Write endpoints are limited to 30 requests per minute per key.

curl -s https://app.mindola.ai/api/v1/lenses \
  -H "Authorization: Bearer mnd_your_api_key_here"

Full field-by-field reference, error codes, and key management in docs/api.md. Runnable examples in curl, Node, and Python live in examples/.

MCP tools

The server exposes exactly three tools:

• create_digital_twin_lens: creates a lens from a profile the user approved in the conversation, and returns the share URL and claim URL.
• add_lens_knowledge: adds up to 20 text or url items to an unclaimed lens by its token; content runs through the standard ingest pipeline so the lens can answer from it with citations.
• get_lens_status: read-only; returns the share URL, whether the lens is claimed, and knowledge counts, useful for polling ingestion progress.

Smoke test the server with plain JSON-RPC, no auth needed:

curl -s https://app.mindola.ai/mcp/lens \
  -H "content-type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Schemas, field limits, and etiquette rules in docs/mcp-tools.md.

Architecture

flowchart LR
    A[MCP client<br>Claude, Cursor, Codex, ChatGPT] -->|create_digital_twin_lens| B[Hosted Mindola MCP server<br>app.mindola.ai/mcp/lens]
    B --> C[Lens created<br>live and unclaimed]
    A -->|add_lens_knowledge| D[Ingestion<br>parse, chunk, embed]
    D --> C
    C --> E[Public lens page<br>mindola.ai/me/your-name]
    V[Visitor] -->|chat or live voice| E
    E -->|grounded answers with citations| V

The server speaks Streamable HTTP (MCP protocol versions 2025-03-26, 2025-06-18, and 2025-11-25) and is stateless. Knowledge you add is parsed, chunked, and embedded, then served through retrieval when a visitor asks a question. More detail, including transport behavior and the unclaimed lens lifecycle, in docs/architecture.md.

FAQ

Is it free to try? Yes. Creating a lens through the MCP server costs nothing and needs no account. Mindola is free to start, and paid plans exist for heavier use.

Do I need an account? Not to create a lens. Anonymous creation gives you an unclaimed lens that is live immediately. You sign up (free) when you claim it.

What is an unclaimed lens? A lens created without an account. It works right away at its share URL and comes with a claim URL. If nobody claims it within 30 days, it expires. Until it is claimed, your assistant can still add knowledge with just the lens token.

Where does my data live? In Mindola's hosted service behind app.mindola.ai. Answers on your lens are grounded in your material, and private material never appears in citations.

Can the lens hallucinate? Answers are grounded in your material only. When a question falls outside it, the lens refuses honestly and can route the question to your inbox instead of guessing.

Can I use my own voice? Yes. Lens owners can use a cloned voice or pick a stock voice for live calls. All generated audio carries a machine-readable marking that identifies it as AI generated.

What languages are supported? The app UI ships in 10 languages: English, Dutch, German, Spanish, French, Arabic, Japanese, Korean, Turkish, and Chinese. When creating a lens you can set a BCP-47 locale for its copy.

How is this different from a custom GPT? A custom GPT lives inside ChatGPT and needs ChatGPT to use. A lens is a public web page anyone can open from a plain link, with grounded citations, honest refusals, live voice, an inbox for missed questions, and optional Stripe payments. We built it to be the front door for your knowledge, not a chat inside someone else's app.

More questions and longer answers in docs/faq.md.

Limitations

Honest list of what is not there yet:

• The API and MCP tools accept two knowledge item types today: text and url. Richer source types, such as PDF upload and Q&A pairs, live in the Mindola app.
• No webhooks yet; poll get_lens_status or GET /api/v1/lenses/:id for ingestion progress.
• No delete-lens endpoint in API v1.
• No official SDK packages yet; examples use plain curl, fetch, and requests.
• Unclaimed lenses expire after 30 days if never claimed.
• Anonymous MCP rate limits: lens creation 2 per minute and 10 per hour per session, and 20 calls per minute per IP for the other two tools. REST write endpoints allow 30 requests per minute per key.

The API is small and early, and more endpoints are coming.

Security

• No auth on the MCP server, by design. Anonymous calls can only create unclaimed lenses, which are rate limited (2 per minute, 10 per hour) and expire in 30 days unless claimed. Ownership is established at the claim step, when the lens is tied to a signed-in account. After that, anonymous connectors can no longer modify it.
• API keys are handled carefully. Keys are shown once at creation. Only a SHA-256 hash is stored, with the first 12 characters kept as a display prefix, and revocation is a timestamp, so it is auditable.
• Grounding as a safety property. Answers come only from owner material, and private material never appears in citations.
• EU AI Act compliance. Voice audio generated by a lens carries an EU AI Act Article 50(2) compliant machine-readable marking, so it is detectable as AI generated.
• Responsible disclosure. Found a vulnerability? Email hi@mindola.ai.

License

The documentation and example code in this repository are MIT licensed. The hosted Mindola service itself is closed source.

Links

• Product: mindola.ai
• Live demo lens: mindola.ai/me/charles-darwin
• Machine-readable docs: mindola.ai/llms.txt
• MCP registry entry: ai.mindola/lens at registry.modelcontextprotocol.io
• Starter template: mindola-persona-starter
• Contact: hi@mindola.ai