FastMemory

FastMemory is an ontological clustering engine that transforms flat, unstructured text embeddings into a structured, agent-navigable functional memory graph using the Topology (Component, Block, Function, Data, Access, Event) taxonomy.

Developed by FastBuilder.AI, FastMemory bridges the gap between shallow vector retrieval (RAG) and deterministic computational memory.

🏆 State-of-the-Art (SOTA) Performance

FastMemory has officially achieved SOTA status on 13 distinct benchmarks (including FinanceBench, FRAMES, LongBench, GraphRAG-Bench, and HaluEval), comprehensively outperforming standard vector RAG architectures in massive multi-hop reasoning, logic extraction, and deterministic pathfinding.

Explore the full benchmark matrix and transparent execution traces on our official Hugging Face Model Card.

⚡ Quickstart: Try the RAG-Replacement

Run the FastMemory Demonstration Notebook (fastmemory_demo.ipynb): Basic Topology Architecture.
Run the FinanceBench SOTA Notebook (fastmemory_financebench_sota.ipynb): Advanced multi-hop financial reasoning.

🤬 Developer Pain Points & The FastMemory Solution

Building reliable AI agents on top of massive Enterprise codebases and datasets is incredibly hard. FastMemory directly solves the three biggest pain points developers face today:

RAG Hallucinations: Standard vector similarity retrieves unrelated text chunks just because they share keywords (e.g., retrieving the "Login Code" when the user asked about the "Login Bug Ticket"). FastMemory provides Deterministic Pathfinding through isolated functional clusters.
Context Fragmentation: Naive text chunking destroys logical boundaries, losing the surrounding context of a function. FastMemory parses semantic topologies into grouped Cognitive Blocks, providing the AI with sibling functions and deterministic access restrictions.
Graph DB Sync Overhead: Piping hierarchical data into Neo4J normally requires complex, fragile NLP and ETL pipelines. The FastMemory Rust engine does this natively in milliseconds using structural Louvain clustering.

🗺️ The Google Maps Analogy

Imagine opening Google Maps, but all you can see are roads and paths. There are no building names, no entry gates, no transaction information for the buildings, and no communication routing.

If you asked a humanoid robot to navigate to a hospital using this map, it would only see a "road to a doctor", a "road to a bed", a "road to a nurse", and a "road to a pharmacy." It would have a profoundly hard time knowing the modes and modality of how to actually behave, act, and pursue every target differently depending on context.

That is exactly what happens when you use standard RAG, semantic ontologies, or flat vector graphs.

| Standard Ontology / RAG | FastMemory Topology Map | | :---------------------------------------------------------: | :--------------------------------------------------------------: | | <img src="https://raw.githubusercontent.com/FastBuilderAI/memory/main/example/analogies/roads_only.png" width="100%" /> | <img src="https://raw.githubusercontent.com/FastBuilderAI/memory/main/example/analogies/structured_city.png" width="100%" /> |

You simply have node-to-node semantic edges. You possess the "roads" (cosine similarity), but you lack the "buildings" (Functional Components) and the "rules of entry/engagement" (Access and Events).

FastMemory solves this. We utilize high-speed Community Detection (Louvain clustering) to mathematically derive and enhance this network of data for direct AI usage, translating raw text into executable cognitive blocks.

🔍 Features & Benefits

Topology Ontology: Information isn't just stored; it is classified into Components, Blocks, Functions, Data, Access restrictions, and Events.
Deterministic Pathfinding: Eliminates RAG hallucinations. An AI doesn't "guess" the answer based on semantic proximity; it traverses a rigorous, rule-based logic graph.
The Agentic Query Engine: Deep recursive subtree targeting. When you query FastMemory, it doesn't just return a matching string—it returns the deepest logical encompassing Block, providing the AI with sibling functions and contextual boundaries.
Enterprise Native: Designed to sit on top of Datawarehouses, SAP, Databricks, AWS Glue, and Fabric.

📊 Before & After FastMemory

Standard vector RAG databases index chunks individually, often losing the multi-hop reasoning capability required to trace dependencies. FastMemory restructures these into event-driven, hierarchical memory blocks.

(You can open the interactive D3.js visualizations directly in your browser from the example/ directories!)

🏥 Health Science

| Before: Flat Semantic Vectors | After: Clustered Functional Memory Graph | | :----------------------------------------------------------: | :---------------------------------------------------------: | | <img src="https://raw.githubusercontent.com/FastBuilderAI/memory/main/example/health_science/before.png" width="100%" /> | <img src="https://raw.githubusercontent.com/FastBuilderAI/memory/main/example/health_science/after.png" width="100%" /> |

🤖 Robotics

| Before: Flat Semantic Vectors | After: Clustered Functional Memory Graph | | :----------------------------------------------------: | :---------------------------------------------------: | | <img src="https://raw.githubusercontent.com/FastBuilderAI/memory/main/example/robotics/before.png" width="100%" /> | <img src="https://raw.githubusercontent.com/FastBuilderAI/memory/main/example/robotics/after.png" width="100%" /> |

🚗 Driverless Cars

| Before: Flat Semantic Vectors | After: Clustered Functional Memory Graph | | :-----------------------------------------------------------: | :----------------------------------------------------------: | | <img src="https://raw.githubusercontent.com/FastBuilderAI/memory/main/example/driverless_cars/before.png" width="100%" /> | <img src="https://raw.githubusercontent.com/FastBuilderAI/memory/main/example/driverless_cars/after.png" width="100%" /> |

📈 Business Analytics

| Before: Flat Semantic Vectors | After: Clustered Functional Memory Graph | | :--------------------------------------------------------------: | :-------------------------------------------------------------: | | <img src="https://raw.githubusercontent.com/FastBuilderAI/memory/main/example/business_analytics/before.png" width="100%" /> | <img src="https://raw.githubusercontent.com/FastBuilderAI/memory/main/example/business_analytics/after.png" width="100%" /> |

✉️ Email Analysis

| Before: Flat Semantic Vectors | After: Clustered Functional Memory Graph | | :----------------------------------------------------------: | :---------------------------------------------------------: | | <img src="https://raw.githubusercontent.com/FastBuilderAI/memory/main/example/email_analysis/before.png" width="100%" /> | <img src="https://raw.githubusercontent.com/FastBuilderAI/memory/main/example/email_analysis/after.png" width="100%" /> |

📋 Audit Operations

| Before: Flat Semantic Vectors | After: Clustered Functional Memory Graph | | :-------------------------------------------------: | :------------------------------------------------: | | <img src="https://raw.githubusercontent.com/FastBuilderAI/memory/main/example/audit/before.png" width="100%" /> | <img src="https://raw.githubusercontent.com/FastBuilderAI/memory/main/example/audit/after.png" width="100%" /> |

🌍 World Events

| Before: Flat Semantic Vectors | After: Clustered Functional Memory Graph | | :--------------------------------------------------------: | :-------------------------------------------------------: | | <img src="https://raw.githubusercontent.com/FastBuilderAI/memory/main/example/world_events/before.png" width="100%" /> | <img src="https://raw.githubusercontent.com/FastBuilderAI/memory/main/example/world_events/after.png" width="100%" /> |

📦 Installation

Rust (Cargo) - CLI Utility To install the standalone fastmemory CLI tool for terminal, server, or MCP usage:

cargo install fastmemory

Python (PyPI) - Native Import To install the high-speed Python module (built natively via PyO3) for direct integration into your Python AI applications:

pip install fastmemory

🚀 Usage Guide

FastMemory can be utilized natively from the command line, spun up as an enterprise REST server, or imported directly into your Python scripts.

1. Terminal CLI (via Cargo)

# Build the memory graph from an ATF Markdown file
$ fastmemory build data/input.md

# Instantly query the hierarchical graph
$ fastmemory query data/input.md "reimbursement"

2. Python (Direct Import)

By utilizing our pip module, your Python loops can pass markdown directly to the compiled Rust engine without any JSON/CLI overhead. The resulting graph JSON is computed instantly via Louvain community detection.

import fastmemory

# 1. Define or fetch your

Memory

Install / Use

README