EigenLens by Eigenlake

Give your agents
more than search.

Connect your agents to existing embeddings for patterns and evidence beyond similarity search.

Get started Explore use cases

Clustering + topic discovery available today.
Self-host with Docker. Connect through MCP.

Your stack, connected.

Your agents

Codex

OpenCode

Pi coding agent

Grok BotCustom agent

EigenLensVector intelligenceClustering + TopicsAvailable today

Your vector data

Qdrant

pgvector

Chroma

01 / 04An agent asks

Connection examples · Requirements vary · Logos belong to their owners.

Existing embeddings. A broader field of view.For developers, agents, and the applications they power.

Context for your LLM

Find examples.
Discover patterns.

Clustering + topic discovery available today.

Same question: What payment issues come up?

Same 1,236 records

Typical retrieval-only RAG

Matching examples

“Why is my payment pending?”

“There is a payment in the app I did not make”

“Why has my card payment been declined?”

RAG + EigenLens

Examples + patterns

1 point = 1 record · gray = unassigned

3 of 18 groups852 unassigned

Show examples from the largest group

Pending card payments

74 records in this group

“Why is my payment pending?”

banking77:test:1598

Topic phrases: pending · payment pending · pending payment

Saved BANKING77 analysis · same 1,236 records

Static comparison

Use cases

Your agent asks: What should support improve?

Support inbox

100 messages

Card payment declined
Transfer still pending
ATM debited, no cash
Recovery email never arrives

Your app: vectors, text, IDs

Read

EigenLens MCP

Cluster

Card payments42
Transfers28
Withdrawals18
Account access12

Find topics

Return

Agent response

Support work plan

70% concern payments or transfers.

Draft decline and transfer FAQs.
[1][2]
Reconcile ATM debits.
[3]
Check recovery emails.
[4]

BANKING77-inspired sample · simulated response

Use EigenLens through MCP

Give your agent
the setup.

Run EigenLens on your machine and connect its MCP server to the coding agent you already use. Copy the prompt and let your agent work through the setup.

01
Run the Docker worker.
Pull the image, start the container, and check that it’s healthy.
02
Connect your existing data.
Use your Qdrant database if one is configured. Your database stays the source; selected records are copied into local snapshots for analysis.
03
Add MCP to your agent.
Save the endpoint and authentication in your agent’s configuration, then verify its EigenLens tools. Clustering and topic discovery are available today.

docker pull eigenlake/eigenlens:0.1.0

Follow the setup guide

A prompt for your coding agent

Prompt to instruct your coding agent to setup EigenLens MCP Server

Paste into Codex, Claude Code, OpenCode, Pi, or your own coding agent.

Read the full setup prompt

Prompt to instruct your coding agent to setup EigenLens MCP Server

Use the setup guide at https://www.eigenlake.dev/get-started for the worker’s supported interfaces. Adapt commands to my operating system and shell. Carry out the setup, preserving existing agent settings, Docker resources, database contents, and secrets. Ask only for information or approval you actually need.

1. Inspect the environment.
Identify the coding agent and its installed version, configuration scope, operating system, and shell. Check that Docker is installed and its daemon is running. Inspect relevant project configuration and running Docker services for an existing Qdrant endpoint. Do not print secrets. If more than one database is plausible, ask which to use. If Docker is unavailable, explain what is needed before continuing.

2. Prepare the worker and any existing Qdrant connection.
Use a private deployment directory such as ~/eigenlens-deploy, outside version control. Reuse an existing EigenLens deployment and its secrets when present. Otherwise create a private .env containing a cryptographically random EIGENLENS_MCP_TOKEN, EIGENLENS_CONNECTION_KEY (a URL-safe base64-encoded 32-byte key), and EIGENLENS_WORKERS=1. Keep the connection key with the same persistent data volume. Never commit credentials or include their values in your reply.

If an existing Qdrant database is available, configure these worker variables privately in .env before starting the container:
EIGENLENS_DATABASE_TYPE=qdrant
EIGENLENS_DATABASE_URL=<Qdrant URL reachable from the worker container>
EIGENLENS_DATABASE_API_KEY=<existing API key, only if required>

Inside the worker, localhost refers to the worker itself. For Qdrant on the host, check whether http://host.docker.internal:6333 is reachable. For Qdrant in Docker, join its existing network and use its service name; for a remote database, use its actual URL and TLS settings. Inspect the stored payload and dense-vector field names; set EIGENLENS_DATABASE_OPTIONS with the actual text_field and vector_field mappings if needed. Do not change, reseed, or create Qdrant collections. If no Qdrant is configured, finish the MCP setup and say that a database connection still needs to be supplied.

3. Download and run EigenLens.
Pull this exact public image:
docker pull eigenlake/eigenlens:0.1.0

From the deployment directory, use the following command for a new worker, adjusting the Docker network to reach the existing database when necessary:
docker run -d --name eigenlens-worker --init --restart unless-stopped --publish 127.0.0.1:8020:8000 --memory 8g --cpus 2 --env-file .env --env EIGENLENS_CPU_BUDGET=2 --add-host host.docker.internal:host-gateway --volume eigenlens_worker-data:/data eigenlake/eigenlens:0.1.0

Check for an existing container and port conflicts first. Reuse a suitable worker; do not delete an existing container or volume. If changing an existing deployment requires recreation or a different port, explain the specific change and get any required approval, preserve its data and connection key, and update the MCP URL consistently. Wait for http://127.0.0.1:8020/health to succeed and inspect relevant startup errors if it fails.

4. Add MCP to the coding agent I am using.
Use Streamable HTTP at http://127.0.0.1:8020/mcp, authenticated with Authorization: Bearer <EIGENLENS_MCP_TOKEN>. Load the same token from the private .env into the environment of the agent process. Docker’s --env-file does not set the client’s environment, and exporting a variable in a subprocess does not update an already-running agent. Arrange a private launcher or explain the exact relaunch step so the token is available in future sessions. Merge only the EigenLens entry; preserve all unrelated configuration and avoid duplicate registrations.

For Codex, use the installed CLI’s supported MCP command:
codex mcp add eigenlens-http --url http://127.0.0.1:8020/mcp --bearer-token-env-var EIGENLENS_MCP_TOKEN
codex mcp list
This registers the server in Codex configuration. If editing ~/.codex/config.toml directly is necessary, use an mcp_servers.eigenlens-http table with url = "http://127.0.0.1:8020/mcp" and bearer_token_env_var = "EIGENLENS_MCP_TOKEN". Verify the installed version’s configuration format.

For Claude Code, merge the following into the current project’s .mcp.json, keeping the environment-variable reference literal:
{
  "mcpServers": {
    "eigenlens": {
      "type": "http",
      "url": "http://127.0.0.1:8020/mcp",
      "headers": {
        "Authorization": "Bearer ${EIGENLENS_MCP_TOKEN}"
      }
    }
  }
}
Validate with claude mcp list and /mcp. Explain any project-trust approval or restart needed.

For Pi coding agent, configure a compatible custom MCP integration. Inspect the installed version and any existing extension or bridge, follow that integration’s documentation, and persist the endpoint and authentication in its supported configuration. If a custom integration must be added, explain the dependency and obtain any required approval before installing it. Do not invent a built-in mcpServers setting or claim the integration is verified before testing it.

For OpenCode, Cursor, or another coding agent, inspect its installed version and official MCP documentation, then add the same endpoint and authentication to its actual supported configuration. OpenCode’s client support alone does not establish a tested EigenLens integration. Preserve existing settings and do not assume all clients use the same JSON schema or environment-variable syntax.

5. Verify the connection.
Reload or reconnect the agent when supported, discover the EigenLens MCP tools, and call get_capabilities. If the running session cannot reload its MCP configuration, distinguish a successful endpoint check from an agent connection that still requires a restart.

If Qdrant was configured, call connect_database with no arguments to use the worker’s private connection settings, then list_collections with the returned connection_id. Let me choose the collection and selection scope before retrieving records or starting analysis. Current analysis is clustering and topic discovery. Selected vectors, text, and metadata are copied into local snapshots in the EigenLens worker; the existing database remains the source system.

Finish with the image version, container status, health check, configuration file changed, MCP connection status, and Qdrant connection status. Include any exact next step or unresolved failure without exposing secrets or inventing successful results.

Built for open adoption

For everyone.
For the long run.

We’re building EigenLens as an open-source project that anyone can use for any purpose. And we’re committed to keeping it that way.

The public Docker image is available now. Public source release is planned. Our priority is helping people solve real problems and shape what we build next.

Explore the Docker image

Ideas & practical guides

Go a little deeper.

All articles

FIELD NOTES / 01

Beyond the Stars: What to Fix to Improve Your Amazon Ratings

How product teams can use EigenLens to uncover recurring problems in Amazon reviews and identify improvements worth investigating to improve customer ratings.

Read article

FIELD NOTES / 02

Use Case 1: Exploring Medical Device Reports with RAG and EigenLens

A measured comparison of top-N RAG and EigenLens over 20,000 device-event reports, with cluster explanations and business value.

Read article

FIELD NOTES / 03

Use Case 2: How EigenLens Helps Engineering Teams Decide What to Investigate Next

How an aviation company’s engineering team can use EigenLens to uncover recurring issues in NTSB reports and prioritize investigations into engine power loss.

Read article

FIELD NOTES / 04

Introducing EigenLens

Evidence beyond search, built on the embeddings you already have.

Read article

FIELD NOTES / 05

Your first vector analysis with EigenLens

Connect your data and inspect your first clustering and topic results.

Read article

FIELD NOTES / 06

Give agents evidence beyond search results

Carry groups, topics, and source records into your agent’s next step.

Read article

A few useful details

Before you
plug in.

What can I use today?

Connect to existing vector data, select records, discover clusters, extract topic terms, and inspect the records behind the results. Developers and agents can use these outputs in their own workflows through MCP. A Python SDK also exists; the public setup path currently uses Docker.

Do I need to move to a new vector database?

Your existing vector database remains the source system. EigenLens reads selected vectors, text, and metadata into local snapshots and runs analysis in your self-hosted worker. It stores those snapshots and results in its own data volume; analysis does not run inside the source database.

Which vector databases can I connect?

The Docker worker includes adapters for Qdrant, PostgreSQL with pgvector, Pinecone, Weaviate, and Milvus. Chroma support is planned. Backend requirements differ: for example, Pinecone full scans require serverless indexes, and Weaviate needs HTTP and gRPC access. The setup guide covers these differences.

Can I reuse the embeddings I already have?

Yes, when the embeddings are suitable for the task and share the same embedding space. Analysis uses stored dense vectors. Include source text for readable topic terms and examples. A text-query selection may separately need the matching embedding model; matching dimensions alone is not enough.

Is EigenLens open source?

We’re building EigenLens as an open-source project for anyone to use for any purpose, and it will remain open source. The public Docker image is available now. The public source release is planned; we have not announced a source-release date or license yet.

Can this work beyond text embeddings?

The vector-operation layer can work with suitable dense embeddings. Images, audio, sensor windows, molecules, and CAD each need an appropriate encoder, metric, context, and evaluation. Different embedding spaces are not interchangeable. Topic terms require source text; aligned multimodal workflows and domain-specific constraints need additional components.

Build with Eigenlake

What should your
embeddings make possible?

Start with the tools available today, or bring us the recurring decision you want to make easier.

Get started Schedule a call

Give your agentsmore than search.

Find examples.Discover patterns.

Pending card payments

Use cases

Support inbox

EigenLens MCP

Support work plan

Give your agentthe setup.

Run the Docker worker.

Connect your existing data.

Add MCP to your agent.

For everyone.For the long run.

Go a little deeper.

Beyond the Stars: What to Fix to Improve Your Amazon Ratings

Use Case 1: Exploring Medical Device Reports with RAG and EigenLens

Use Case 2: How EigenLens Helps Engineering Teams Decide What to Investigate Next

Introducing EigenLens

Your first vector analysis with EigenLens

Give agents evidence beyond search results

Before youplug in.

What should yourembeddings make possible?

Give your agents
more than search.

Find examples.
Discover patterns.

Give your agent
the setup.

For everyone.
For the long run.

Before you
plug in.

What should your
embeddings make possible?