You're building an AI agent for legal teams. Or financial analysts. Or customer support. Your agent is good at reasoning over context. The problem is getting it the right context in the first place.
You tried vector search. It works for simple questions. But when your enterprise customer asks something that spans multiple contracts, references a decision from six months ago, or requires tracing how a clause was amended across revisions, your agent returns fragments instead of answers.
You could build a knowledge graph pipeline yourself. Extract entities, normalize names, store triples, build traversal logic, handle contradictions, version facts over time. Most teams estimate 6-12 months for this. Your engineers should be building your product, not infrastructure.
This is the problem Vrin solves. You build the agent. Vrin handles the knowledge reasoning.
The Architecture
Here is how a vertical AI company typically integrates Vrin:
Your Agent (Legal AI, Financial AI, etc.) calls Vrin via SDK, MCP, or REST API. Vrin's Knowledge Reasoning Engine processes the query against the customer's Knowledge Graph (entities, relationships, temporal facts), Vector Store (document chunks, semantic search), and Consolidation Pipeline (dedup, contradiction resolution). The customer's data sources feed in: documents, APIs, databases, Slack, Notion, and more.
Your agent sends a question to Vrin. Vrin decomposes it, traverses entity relationships across your customer's knowledge graph, fuses graph facts with document chunks, scores confidence, and returns structured context with source citations. Your agent uses that context to generate an answer it can stand behind.
The key architectural decision: Vrin is a layer, not a replacement. It works with whatever LLM your agent uses. GPT, Claude, Gemini, open-source models. You bring the model. Vrin provides the reasoning infrastructure.
Integration in Practice
Python SDK
The fastest path. Run pip install vrin, create a VRINClient with your API key, and call client.query() with your question and a query_depth parameter. The response includes a summary, source documents, extracted facts, and confidence scores. Three lines to add knowledge reasoning to your agent.
The query_depth parameter controls how deep Vrin reasons:
| Depth | What happens | When to use |
|---|---|---|
| basic | Single-hop graph lookup + top-k chunks | Simple factual questions |
| thinking | Multi-hop traversal + expanded search | Questions requiring connections across documents |
| research | Parallel reasoning strategies + exhaustive retrieval | Complex comparative or temporal questions |
Your agent can choose the depth dynamically based on question complexity, or let Vrin auto-route.
MCP Server
If your agent runs in Claude Code, Cursor, Windsurf, or any MCP-compatible environment, Vrin exposes four tools automatically: vrin_query (ask complex questions, get reasoned answers with sources), vrin_retrieve (get structured context for your own generation), vrin_search_entities (find entities in the knowledge graph), and vrin_get_facts (retrieve specific facts about an entity).
Your agent's LLM decides when to call Vrin, what to ask, and how to use the results. No custom integration code needed. The MCP server handles authentication, streaming, and response formatting.
REST API
For non-Python environments or custom architectures, Vrin exposes standard HTTP endpoints. POST to the /query endpoint with your API key, query text, depth, and optional streaming flag. Streaming responses deliver tokens as they're generated via Server-Sent Events. No buffering, no polling.
Data Sovereignty Per Customer
This is where the architecture matters most for vertical AI companies.
Your enterprise customers require their data stays in their cloud. They won't accept a multi-tenant system where their contracts sit alongside a competitor's filings.
Vrin's enterprise routing handles this natively. The API key prefix determines routing: vrin_ keys route to Vrin's shared infrastructure, while vrin_ent_ keys route to the customer's own AWS account.
When you onboard an enterprise customer, their data flows to their own knowledge graph, their own vector store, their own encryption keys. Your agent code doesn't change. The same SDK call works for both paths. Only the API key is different.
This means you can:
- Build and test on Vrin's shared infrastructure (free tier)
- Deploy to each enterprise customer's isolated environment with a key swap
- Scale to hundreds of customers without managing infrastructure per deployment
What Your Agents Get
Traceable answers, not chunks
Every response from Vrin includes the specific facts used, the documents they came from, and confidence scores. Your agent doesn't just say "according to the documents." It says "according to paragraph 4.2 of the 2025 Partnership Agreement, with a confidence score of 0.92."
This is critical for regulated industries. Legal teams need to verify citations. Financial analysts need audit trails. Compliance officers need provenance. Vector search gives you "relevant chunks." Vrin gives you traceable facts.
Temporal awareness
Vrin's knowledge graph versions every fact with timestamps. When your customer asks "What was the policy last quarter?", Vrin returns the Q3 version, not the latest version. When a document update contradicts an older fact, both versions are preserved with their temporal context.
This matters for any domain where facts change over time: financial reporting, regulatory compliance, contract management, clinical guidelines.
A knowledge graph that improves over time
Vrin's consolidation pipeline runs periodically to:
- Deduplicate facts (3-stage cascade: structural blocking, fuzzy matching, LLM verification)
- Detect contradictions (temporal consistency checks)
- Identify communities of related entities (Leiden algorithm)
- Strengthen high-value facts based on usage patterns
The longer your customer uses Vrin, the cleaner and more structured their knowledge graph becomes. This is a compounding advantage that vector-only systems cannot replicate.
Use Cases We're Seeing
Legal AI agents
Law firms and legal tech companies use Vrin to power contract analysis, regulatory compliance, and due diligence agents. The key requirement: every conclusion must trace to specific clauses and precedents. Vrin's fact-level provenance makes this possible without manual citation work.
Financial AI agents
Wealth management and analyst platforms use Vrin to reason across quarterly filings, earnings transcripts, and market data. Temporal versioning tracks how metrics change quarter-to-quarter. Multi-hop reasoning connects revenue changes to leadership decisions to market conditions across different documents.
Healthcare AI agents
Clinical decision support systems use Vrin to connect patient records, research papers, and treatment guidelines. When guidelines are updated, Vrin's contradiction detection flags conflicts with existing facts. Provenance ensures every recommendation traces to specific evidence.
Customer support AI agents
Support platforms embed Vrin to power agents that resolve complex tickets by reasoning across past tickets, knowledge base articles, Slack threads, and product documentation simultaneously. The agent doesn't just find a similar ticket. It traces the resolution path across multiple knowledge sources.
Getting Started
Step 1: Install and try it. Run pip install vrin. The free tier includes 100k chunks, 100k graph edges, and 5k queries per month. Enough to build and validate your integration.
Step 2: Ingest your customer's knowledge. Create a VRINClient, then call client.insert() with text content or client.upload_file() with PDFs and documents. Vrin extracts entities, relationships, and timestamped facts automatically.
Step 3: Query from your agent. Call client.query() with the question and a query_depth. The result includes summary, sources, facts, and confidence.
Step 4: Scale to enterprise. When your customer requires data isolation, swap the API key to their enterprise key. Same code, isolated infrastructure.
The Economics
Building knowledge reasoning infrastructure in-house typically requires:
- 2-3 ML engineers for 6-12 months
- A graph database (Neptune, Neo4j)
- A vector store (OpenSearch, Pinecone)
- Fact extraction pipeline maintenance
- Ongoing consolidation and quality management
With Vrin, you're integrating a few lines of SDK code and focusing your engineering team on what differentiates your product: the agent logic, the user experience, the domain expertise.
The infrastructure layer is our problem. Your product is yours.
Vrin is the reasoning engine behind AI agents that need to be right. Start building at vrin.cloud.
Founder & CEO
Building knowledge reasoning infrastructure for enterprise AI at VRIN. We believe in transparent research and open benchmarks.