⚡ FusionPact

The Agent-Native Retrieval Engine

Hybrid Vector + Reasoning + Memory for AI Agents

Similarity ≠ Relevance. FusionPact is the first retrieval engine that combines HNSW vector search, reasoning-based tree retrieval, and agent memory in a single platform — purpose-built for AI agents and multi-agent systems.

Quickstart · Hybrid Retrieval · Agent Memory · Multi-Agent · MCP Server · Tree Index · RAG Pipeline · API Reference · Benchmarks · Contributing

---

Why FusionPact?

Traditional vector databases retrieve what's similar. But similar ≠ relevant. Ask a vector DB for "Q3 2024 revenue" and you might get Q2 or Q4 data — semantically similar, but the wrong answer.

FusionPact solves this by combining three retrieval paradigms:

Strategy	How It Works	Best For
Vector Search (HNSW)	Embedding similarity, O(log N)	Broad search across large collections
Tree Reasoning	LLM navigates document structure	Precise retrieval in structured documents
Keyword Search (BM25)	Term frequency matching	Exact match requirements

Plus purpose-built agent memory, multi-agent orchestration, and MCP server — all zero-dependency, local-first, and free.

┌──────────────────────────────────────────────────────────┐
│             FusionPact Retrieval Engine                   │
│                                                          │
│  ┌────────────┐  ┌─────────────┐  ┌────────────────┐   │
│  │ Vector     │  │ Tree        │  │ Keyword        │   │
│  │ (HNSW)     │  │ (Reasoning) │  │ (BM25)         │   │
│  └─────┬──────┘  └──────┬──────┘  └───────┬────────┘   │
│        └────────────┬────┴─────────────────┘            │
│                     ▼                                    │
│           Reciprocal Rank Fusion                         │
│                     ▼                                    │
│  ┌──────────────────────────────────────────────────┐   │
│  │        Agent Memory (Multi-Agent)                │   │
│  │  Episodic │ Semantic │ Procedural │ Shared       │   │
│  └──────────────────────────────────────────────────┘   │
│  ┌──────────────────────────────────────────────────┐   │
│  │        MCP Server (Claude, Cursor, etc.)         │   │
│  └──────────────────────────────────────────────────┘   │
└──────────────────────────────────────────────────────────┘

---

⚡ Quickstart

# Install
npm install fusionpact

# Run the demo
npx fusionpact demo

# Start HTTP + MCP server
npx fusionpact serve --port 8080

# Start MCP server for Claude Desktop
npx fusionpact mcp

10 Lines of Code

const { create } = require('fusionpact');

const fp = create({ embedder: 'ollama' }); // or 'mock' for zero-config

// Ingest a document — auto-chunks, embeds, indexes
await fp.rag.ingest('Your document text here...', { source: 'doc.pdf' });

// Hybrid search — vector + reasoning + keyword, fused automatically
const results = await fp.retriever.retrieve('What safety protocols exist?', {
  collection: 'default',
  strategy: 'hybrid'
});

// Or build LLM-ready context directly
const context = await fp.rag.buildContext('What safety protocols exist?');
console.log(context.prompt); // Ready to paste into any LLM

---

🔀 Hybrid Retrieval Engine

The core differentiator: a single API that intelligently routes queries through multiple retrieval strategies and fuses results using Reciprocal Rank Fusion.

const { create } = require('fusionpact');

const fp = create({
  embedder: 'ollama',        // Local, free, private
  llmProvider: 'ollama',     // For tree reasoning
  enableHybrid: true
});

// Index a structured document with tree structure
await fp.treeIndex.indexDocument('annual-report', reportText, {
  format: 'markdown'
});

// Hybrid retrieval — automatically uses the best strategy
const results = await fp.retriever.retrieve(
  'What were the total deferred tax assets in Q3?',
  {
    collection: 'documents',       // Vector search here
    docId: 'annual-report',        // Tree reasoning here
    topK: 5,
    strategy: 'hybrid'            // Fuse all strategies
  }
);

// Each result includes:
// - score: Fused relevance score
// - content: Retrieved text
// - sources: Which strategies contributed { vector: 0.8, tree: 0.9, keyword: 0.3 }
// - citation: "Section 3 > Financial Data > Table 3.2.1"
// - reasoning: Full tree traversal reasoning trace

Strategy Weights

const retriever = new HybridRetriever({
  engine, treeIndex, embedder,
  weights: {
    vector: 0.4,   // 40% weight to vector similarity
    tree: 0.4,     // 40% weight to reasoning-based retrieval
    keyword: 0.2   // 20% weight to keyword matching
  }
});

Adaptive Learning

FusionPact learns which retrieval strategy works best for different query patterns:

// Record feedback on result quality
retriever.recordFeedback('financial query', 'tree', 0.95);
retriever.recordFeedback('general search', 'vector', 0.85);

// Get recommended weights for a new query
const weights = retriever.getAdaptiveWeights('new financial query');
// → { vector: 0.25, tree: 0.6, keyword: 0.15 }

---

🌲 Tree Index

Reasoning-based retrieval for structured documents. Builds a hierarchical tree (like an intelligent table of contents) and uses LLM reasoning to navigate to the most relevant sections.

const { TreeIndex, LLMProvider } = require('fusionpact');

const llm = new LLMProvider({ provider: 'ollama' }); // Free, local
const tree = new TreeIndex({ llmProvider: llm });

// Index a document
await tree.indexDocument('sec-filing', filingText, {
  format: 'markdown',
  metadata: { source: '10-K', year: 2024 }
});

// Reasoning-based search
const results = await tree.search('sec-filing', 'Total deferred tax assets', {
  maxResults: 3,
  includeReasoning: true
});

// results[0]:
// {
//   content: "Table 5.2: Deferred Tax Assets...",
//   relevanceScore: 0.95,
//   citation: "Financial Statements > Note 5 > Tax Assets > Table 5.2",
//   reasoningPath: [
//     { title: "Financial Statements", reasoning: "Deferred tax assets are in financial notes", action: "explore" },
//     { title: "Note 5: Income Taxes", reasoning: "This note covers tax-related assets", action: "explore" },
//     { title: "Table 5.2", reasoning: "Contains the deferred tax asset breakdown", action: "retrieve" }
//   ]
// }

Works Without LLM Too

If no LLM provider is configured, TreeIndex falls back to keyword-based tree traversal — still useful, just without the reasoning path:

const tree = new TreeIndex(); // No LLM — keyword fallback
await tree.indexDocument('doc', text, { format: 'markdown' });
const results = await tree.search('doc', 'safety protocols');

---

🧠 Agent Memory

Purpose-built memory system for AI agents with four memory types:

Memory Type	What It Stores	Example
Episodic	Events, conversations, observations	"User asked about Lab B chemical storage"
Semantic	Facts, domain knowledge, learned info	"OSHA 1910.106 covers flammable liquids"
Procedural	Tool schemas, API specs, workflows	search_incidents tool definition
Shared	Cross-agent knowledge pool	"Customer ACME prefers ISO 14001"

const { create } = require('fusionpact');
const fp = create({ embedder: 'ollama', enableMemory: true });

// Episodic — remember what happened
await fp.memory.remember('agent-1', {
  content: 'User prefers dark mode and concise answers',
  role: 'system',
  importance: 0.8
});

// Semantic — learn knowledge
await fp.memory.learn('agent-1',
  'OSHA 29 CFR 1910 covers general industry safety standards.',
  { source: 'regulations', category: 'compliance' }
);

// Procedural — register tools
await fp.memory.registerTool('agent-1', {
  name: 'search_incidents',
  description: 'Search EHS incident reports by category and severity',
  schema: { type: 'object', properties: { severity: { type: 'string' } } }
});

// Recall — cross-memory search
const memories = await fp.memory.recall('agent-1', 'safety compliance');
// → { episodic: [...], semantic: [...], procedural: [...], shared: [...] }

// Conversation memory
fp.memory.addMessage('agent-1', 'thread-001', { role: 'user', content: 'What are the PPE requirements?' });
fp.memory.addMessage('agent-1', 'thread-001', { role: 'assistant', content: 'PPE requirements include...' });
const history = fp.memory.getConversation('agent-1', 'thread-001');

// GDPR-friendly forget
fp.memory.forget('agent-1', { type: 'all' });

---

🤖 Multi-Agent Orchestration

Coordinate multiple AI agents with isolated memory, shared knowledge, and message routing:

const { create, AgentOrchestrator } = require('fusionpact');

const fp = create({ embedder: 'ollama', enableMemory: true });
const orchestrator = new AgentOrchestrator({
  engine: fp.engine,
  memory: fp.memory,
  retriever: fp.retriever
});

// Register agents
orchestrator.registerAgent({
  agentId: 'researcher',
  name: 'Research Agent',
  role: 'Find and analyze information',
  capabilities: ['search', 'analysis', 'summarization']
});

orchestrator.registerAgent({
  agentId: 'writer',
  name: 'Writing Agent',
  role: 'Generate reports and documentation',
  capabilities: ['writing', 'formatting', 'editing']
});

// Agent-to-agent communication
await orchestrator.send({
  from: 'researcher',
  to: 'writer',
  type: 'result',
  payload: { findings: 'Safety incidents decreased 12% YoY...' }
});

// Capability-based task delegation
await orchestrator.delegate('coordinator', 'Write a safety summary report', {
  requiredCapabilities: ['writing', 'formatting']
});
// → Automatically routes to 'writer' agent

// Collaborative retrieval across all agents
const results = await orchestrator.collaborativeRecall('safety compliance');
// → Returns memories from all agents, plus shared knowledge

// Message handling
orchestrator.onMessage('writer', async (msg) => {
  console.log(`Writer received: ${msg.type} from ${msg.from}`);
  // Process task...
});

---

🔌 MCP Server

FusionPact ships as an MCP (Model Context Protocol) server. Any AI agent (Claude, Cursor, Windsurf) can use it as persistent memory — no custom integration needed.

Claude Desktop Setup

Add to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "fusionpact": {
      "command": "npx",
      "args": ["fusionpact", "mcp"],
      "env": {
        "EMBEDDING_PROVIDER": "ollama"
      }
    }
  }
}

Available MCP Tools

Tool	Description
fusionpact_create_collection	Create HNSW-indexed vector collection
fusionpact_search	Semantic vector search
fusionpact_hybrid_search	Hybrid retrieval (vector + tree + keyword)
fusionpact_rag_ingest	One-click RAG ingestion
fusionpact_rag_query	Build LLM-ready context
fusionpact_memory_remember	Store episodic memory
fusionpact_memory_recall	Recall relevant memories
fusionpact_memory_learn	Add semantic knowledge
fusionpact_memory_share	Share cross-agent knowledge
fusionpact_memory_forget	GDPR-style memory erasure
fusionpact_memory_conversation	Manage conversation threads

---

📄 RAG Pipeline

End-to-end RAG in one call:

const fp = require('fusionpact').create({ embedder: 'ollama' });

// Ingest — auto-chunks, embeds, indexes
await fp.rag.ingest(documentText, {
  source: 'safety-manual.pdf',
  title: 'Safety Manual 2024'
});

// Build context for any LLM
const ctx = await fp.rag.buildContext('What PPE is required?', {
  topK: 5,
  maxTokens: 4000,
  strategy: 'hybrid'  // Uses HybridRetriever if available
});

// ctx.prompt → Ready for any LLM
// ctx.sources → Source citations
// ctx.chunks → Number of chunks used

Chunking Strategies

const rag = new RAGPipeline(engine, {
  chunkStrategy: 'recursive',  // 'recursive' | 'sentence' | 'paragraph'
  chunkSize: 512,
  chunkOverlap: 50
});

---

🔒 Multi-Tenancy

Zero-trust soft-isolation — tenants can never see each other's data:

const tenantA = engine.tenant('shared-collection', 'acme_corp');
const tenantB = engine.tenant('shared-collection', 'globex_inc');

tenantA.insert([{ id: 'doc-1', vector: [...], metadata: { doc: 'Acme Plan' } }]);

// Tenant A queries — only sees Acme data. Always.
const results = tenantA.search(queryVec, { topK: 10 });

---

🔌 Embedding Providers

Provider	Setup	Dimensions	Cost
Ollama (recommended)	ollama pull nomic-embed-text	768	Free
OpenAI	Set OPENAI_API_KEY	1536	~$0.02/1M tokens
Mock (testing)	None	64	Free

// Ollama (local, free, private)
const fp = create({ embedder: 'ollama' });

// OpenAI
const fp = create({ embedder: 'openai', openaiConfig: { apiKey: 'sk-...' } });

// Mock (for demos/testing — no dependencies)
const fp = create({ embedder: 'mock' });

---

📊 Benchmarks

HNSW Performance (128D vectors)

Vectors	Insert	Search (p50)	QPS
1,000	15ms	0.2ms	~5,000
10,000	180ms	0.3ms	~3,300
100,000	2.8s	0.5ms	~2,000

Run your own:

npx fusionpact bench --count 10000

---

🆚 Comparison

Feature	FusionPact	PageIndex	Pinecone	Chroma	Qdrant
Hybrid Retrieval (Vector+Tree+Keyword)	✅	❌	❌	❌	❌
Reasoning-Based Tree Index	✅	✅	❌	❌	❌
Agent Memory Architecture	✅	❌	❌	❌	❌
Multi-Agent Orchestration	✅	❌	❌	❌	❌
MCP Server (Agent-Native)	✅	✅	❌	❌	❌
One-Click RAG	✅	❌	❌	❌	❌
Multi-Tenancy	✅	❌	✅	❌	✅
Local-First / Zero-Cost	✅	✅	❌	✅	✅
HNSW Vector Index	✅	❌	✅	✅	✅
Zero Dependencies	✅	❌	❌	❌	❌

---

📖 API Reference

Full documentation: docs/API.md

Core Classes

Class	Description
FusionEngine	Core database engine, collection management, CRUD
HNSWIndex	HNSW approximate nearest neighbor index
TreeIndex	Hierarchical document index for reasoning retrieval
HybridRetriever	Multi-strategy retrieval with rank fusion
AgentMemory	Multi-type agent memory system
AgentOrchestrator	Multi-agent coordination layer
RAGPipeline	End-to-end RAG pipeline
MCPServer	Model Context Protocol server
OllamaEmbedder	Ollama embedding provider
OpenAIEmbedder	OpenAI embedding provider
MockEmbedder	Testing/demo embedder
LLMProvider	Multi-provider LLM interface

---

🗺 Roadmap

• [x] HNSW indexing with configurable M/ef parameters
• [x] Multi-tenancy with soft-isolation
• [x] One-Click RAG pipeline
• [x] Agent Memory (episodic, semantic, procedural, shared)
• [x] Multi-agent orchestration
• [x] Tree Index (reasoning-based retrieval)
• [x] Hybrid Retriever (vector + tree + keyword fusion)
• [x] MCP server (stdio + HTTP)
• [x] HTTP API server
• [x] Ollama + OpenAI embedding providers
• [x] Adaptive retrieval learning
• [ ] SQLite/PostgreSQL persistence
• [ ] Python SDK (pip install fusionpact)
• [ ] LangChain integration
• [ ] LlamaIndex integration
• [ ] CrewAI / AutoGen integration
• [ ] Vision RAG (PDF page images)
• [ ] Rust core (NAPI bindings)
• [ ] FusionPact Cloud (managed hosting)
• [ ] Dashboard UI

---

🤝 Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

git clone https://github.com/FusionpactTech/fusionpact-vectordb.git
cd fusionpact-vectordb
npm install
npm test
npx fusionpact demo

---

📜 Attribution

FusionPact is built and maintained by FusionPact Technologies Inc.

If you use FusionPact in your project, please include attribution in one of the following ways:

• Include "Powered by FusionPact" in your application's about page or documentation
• Keep the NOTICE file in your distribution
• Reference FusionPact Technologies Inc. in your project's acknowledgements

See ATTRIBUTION.md for full details.

License

Apache 2.0 — Use freely in commercial and open-source projects.

The Apache 2.0 license requires that you:

1. Include a copy of the license in any redistribution
2. Include the NOTICE file with attribution to FusionPact Technologies Inc.
3. State any significant changes you made to the code

---

Built with ❤️ by FusionPact Technologies Inc.

⭐ Star this repo if you find it useful!