⚡ FusionPact
The Agent-Native Retrieval Engine
Hybrid Vector + Reasoning + Memory for AI Agents
Power your agent
पब्लिशर की अपनी कमांड। PlugMCP एंडपॉइंट नहीं।
Host a copy with our keys and logs.
npx -y [email protected]Claude Code में लोकल कमांड के लिए इंस्टॉल लिंक नहीं है। नीचे दी गई कमांड कॉपी करें और टर्मिनल में चलाएँ।
EMBEDDING_PROVIDER=<value> claude mcp add io.github.atul-fusionpact-fusionpact-vectordb -- npx -y fusionpact@2.1.1टर्मिनल में चलाएँ।
{ "mcpServers": { "io.github.atul-fusionpact-fusionpact-vectordb": { "command": "npx", "args": [ "-y", "[email protected]" ], "env": { "EMBEDDING_PROVIDER": "<value>" } } }}claude_desktop_config.json
रिमोट URL या आपकी मशीन पर कमांड? दोनों इंस्टॉल में क्या अंतर है
PlugMCP पर चलाएँ
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
लॉन्च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
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:
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.) │ │
│ └──────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────┘
# 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
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
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
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
}
});
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 }
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" }
// ]
// }
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');
Purpose-built memory system for AI agents with four memory types:
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' });
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...
});
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.
Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"fusionpact": {
"command": "npx",
"args": ["fusionpact", "mcp"],
"env": {
"EMBEDDING_PROVIDER": "ollama"
}
}
}
}
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
const rag = new RAGPipeline(engine, {
chunkStrategy: 'recursive', // 'recursive' | 'sentence' | 'paragraph'
chunkSize: 512,
chunkOverlap: 50
});
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 });
// 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' });
Run your own:
npx fusionpact bench --count 10000
Full documentation: docs/API.md
pip install fusionpact)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
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:
NOTICE file in your distributionSee ATTRIBUTION.md for full details.
Apache 2.0 — Use freely in commercial and open-source projects.
The Apache 2.0 license requires that you:
Built with ❤️ by FusionPact Technologies Inc.
⭐ Star this repo if you find it useful!
Hybrid vector + reasoning retrieval, agent memory, multi-agent orchestration, MCP server, and RAG.
{ "mcpServers": { "io.github.atul-fusionpact-fusionpact-vectordb": { "command": "npx", "args": [ "-y", "[email protected]" ], "env": { "EMBEDDING_PROVIDER": "<value>" } } }}टूल
अभी टूल सूची नहीं है। रिमोट सर्वर को पहले हेल्थ चेक के बाद सूची मिलती है।
FAQ
इस पेज पर Cursor, Claude Desktop, Claude Code या VS Code के लिए stdio कॉन्फ़िग कॉपी करें। यह पब्लिशर का इंस्टॉल इस्तेमाल करता है, PlugMCP प्रॉक्सी नहीं।
पब्लिशर ने ये एनवायरनमेंट वेरिएबल बताए हैं: EMBEDDING_PROVIDER।
Fusionpact Vectordb stdio पर लोकल चलता है।
पिछली जाँच 2026-11-09 को हुई। Hybrid vector + reasoning retrieval, agent memory, multi-agent orchestration, MCP server, and RAG.