Pre-emptive ontology database that stores facts instead of text for LLMs. Rather than filling context windows with massive text that LLMs must interpret, FluxDB enables agents to retrieve structured facts on-demand and automatically infer new knowledge from domain ontologies - making sensing, reasoning, and knowledge discovery ultra-fast. Purpose-built for agentic systems that need rapid access to complex relationships and automated inference across code and domain knowledge.
From RAG pipelines to complex knowledge graphs, FluxDB delivers enterprise-grade performance with zero-configuration simplicity
Built on high-performance BTree storage with 6-index hexastore architecture. Query latency under 1ms for indexed patterns, 10-50ms REST API response times.
Purpose-built for retrieval-augmented generation (RAG) with structured fact storage, explainable retrieval, and seamless LangChain compatibility.
RDF triple storage with relationship discovery, transitive closure, and graph traversal operations.
SPARQL 1.1 queries with SELECT, WHERE, LIMIT, OFFSET, DISTINCT, COUNT, and natural language translation.
Low-latency HTTP API with JSON responses, health checks, and OpenAPI specification.
Type-safe client with streaming iterators, connection pooling, and zero external dependencies.
Full transactional support with crash recovery, persistent storage, and data integrity guarantees.
Optional forward-chaining with automatic type propagation and relationship inference.
Quad store capability for organizing triples into named contexts and datasets.
Zero-configuration deployment with single-file storage and no external dependencies.
Concurrent read access from multiple clients without performance degradation.
44+ documentation files with guides, examples, API references, and performance tuning.
FluxDB outperforms traditional solutions with specialized indexing and optimized query execution
FluxDB is engineered from the ground up to support agentic harnesses requiring rapid access to knowledge bases founded on code and domain ontologies
FluxDB provides purpose-built infrastructure for agentic systems that need to reason over code ontologies and domain knowledge. AI agents leverage FluxDB's sub-millisecond queries to access rich ontological relationships between legacy code, business logic, and modernized components. Purpose-designed for agentic harnesses performing legacy modernization, brownfield development, and autonomous code generation.
Transform legacy codebases (COBOL, Mainframe, legacy Java) into rich code ontologies that agentic harnesses can reason over. AI agents access FluxDB's ontological knowledge base to understand code relationships, dependencies, and business logic before autonomously generating modern equivalents with complete traceability.
Build living ontological knowledge bases of existing systems that agentic harnesses continuously query and update. AI agents leverage FluxDB's domain and code ontologies to autonomously propose safe changes, identify affected components, and execute migration strategies for large-scale projects.
Enable agentic systems to autonomously generate comprehensive SDLC documentation by querying FluxDB's code and domain ontologies. AI agents produce architecture diagrams, API specs, migration plans, test strategies, and compliance reports directly from ontological knowledge.
Purpose-built for AI agent systems requiring real-time access to code and domain ontologies. FluxDB serves as the ontological knowledge base for agentic harnesses, enabling agents to reason over complex code relationships, domain semantics, and business logic with sub-millisecond latency.
Parse legacy codebase into ontological triples representing classes, methods, dependencies, and domain-specific business rules
AI agents query FluxDB's ontological knowledge base to understand code structure, reason over domain semantics, and identify patterns
Agentic systems produce modernized code while maintaining ontological relationships and traceability in FluxDB
Agents auto-generate SDLC artifacts, migration documentation, and compliance reports from ontological knowledge base
FluxDB provides the code and domain ontology foundation that agentic harnesses need for reliable, autonomous modernization and development.
Build Your Agentic Knowledge BaseFluxDB works with your existing tools and frameworks
Type-safe client with CLI, REST, and SPARQL interfaces. Zero dependencies, context managers, and streaming support.
FluxDBRetriever provides seamless LangChain integration for RAG pipelines with structured fact retrieval.
HTTP API with JSON responses, OpenAPI spec, health checks, and low-latency performance.
Full SPARQL 1.1 support with natural language translation, interactive CLI, and multiple output formats.
Complete CLI toolkit: odb_server, odb_query, odb_load, odb_sparql, odb_stat for all database operations.
Native support for RDF/XML, Turtle, N-Triples, and JSON-LD formats for data import and export.
From LLM pipelines to enterprise knowledge management
Provide LLMs with structured facts and relationships. FluxDB delivers 10-50ms retrieval times with explainable graph paths, perfect for retrieval-augmented generation workflows.
Build comprehensive knowledge graphs with entities, relationships, and properties. Native RDF support and transitive closure enable complex graph queries.
Convert technical documentation into structured knowledge. Natural language SPARQL translation enables intuitive querying with fast answer retrieval.
Model products with attributes, compatibility, dependencies, and hierarchies. Graph queries reveal relationships and enable recommendation systems.
Track researchers, publications, citations, institutions, and topics. Discover collaboration networks and research impact with graph analytics.
Extract knowledge from legacy systems and build knowledge graphs from code, documentation, and system relationships for modernization planning.
Real-world query examples from FluxDB documentation - copy, paste, and run against the included university & student ontology sample database
Retrieve all triples with pagination
SELECT * WHERE { ?s ?p ?o } LIMIT 10
Query all PhD students in the database
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX onto: <http://academic-network.org/ontology#>
SELECT ?person WHERE {
?person rdf:type onto:PhDStudent .
}
Find students and their supervisors
SELECT ?person ?supervisor WHERE {
?person rdf:type onto:PhDStudent .
?person onto:supervisedBy ?supervisor .
}
Ask questions in plain English
./tools/fluxdb-sparql -d /tmp/demo_db --nl "Who are the PhD students?"
./tools/fluxdb-sparql -d /tmp/demo_db --nl "How many professors are there?"
./tools/fluxdb-sparql -d /tmp/demo_db --nl "List all researchers"
Verify server status
curl http://localhost:8080/health
# Response:
# {"status":"ok"}
Fast count-only query
curl 'http://localhost:8080/triples?count=true'
# Response:
# {"count":1043}
Query specific relationship types
curl 'http://localhost:8080/triples?predicate=http%3A%2F%2Fwww.w3.org%2F1999%2F02%2F22-rdf-syntax-ns%23type&limit=10'
Integrate with web applications
const fetch = require('node-fetch');
async function queryTriples(params) {
const url = new URL('http://localhost:8080/triples');
Object.keys(params).forEach(key =>
url.searchParams.append(key, params[key])
);
const response = await fetch(url);
return await response.json();
}
// Usage
queryTriples({ limit: 10 }).then(data => {
console.log(`Found ${data.count} triples`);
});
Answer: 15 students
odb_query -d /tmp/demo_db \
-p "http://www.w3.org/1999/02/22-rdf-syntax-ns#type" \
-o "http://academic-network.org/ontology#PhDStudent" | wc -l
Query by affiliation
odb_query -d /tmp/demo_db \
-p "http://academic-network.org/ontology#affiliatedWith" \
-o "http://academic-network.org/data/org/MIT"
Answer: 18 papers
odb_query -d /tmp/demo_db \
-p "http://academic-network.org/ontology#aboutTopic" \
-o "http://academic-network.org/ontology#DeepLearning" | wc -l
Full-featured CLI with history
./tools/fluxdb-sparql -d /tmp/demo_db --interactive
>>> /nl How many professors are there?
>>> /format json
>>> /sparql SELECT * WHERE { ?s ?p ?o } LIMIT 5
>>> /help
Query via HTTP API
from fluxdb import RESTClient
client = RESTClient("http://localhost:8080")
# Query with filters
results = client.query(
predicate="rdf:type",
limit=10
)
for triple in results:
print(f"{triple['subject']} → {triple['object']}")
Direct database access
from fluxdb import CLIClient
client = CLIClient("/tmp/demo_db")
# Pattern query
results = client.query_pattern(
predicate="http://onto.org/type",
obj="http://onto.org/PhDStudent"
)
print(f"Found {len(results)} PhD students")
Execute SPARQL queries from Python
from fluxdb import SPARQLExecutor
executor = SPARQLExecutor("/tmp/demo_db")
# SPARQL query
query = """
SELECT ?person ?name WHERE {
?person rdf:type onto:Professor .
?person onto:name ?name .
}
"""
results = executor.execute(query)
for row in results:
print(f"{row['name']}")
LangChain integration for RAG
from fluxdb import FluxDBRetriever
retriever = FluxDBRetriever(
database="/tmp/demo_db",
top_k=5
)
# Get context for LLM
docs = retriever.get_relevant_documents(
"Who are experts in Machine Learning?"
)
for doc in docs:
print(doc.page_content)
Zero configuration required. Start building with FluxDB today.
Get FluxDB and build with a single command
cd fluxdb
make
Launch the REST API server on your preferred port
./tools/build/bin/odb_server -p 8080 ./database
Run SPARQL queries via CLI or natural language
./tools/build/bin/odb_sparql ./database
> SELECT * WHERE { ?s ?p ?o } LIMIT 10
Use the Python SDK for LLM and RAG applications
from fluxdb import RESTClient
client = RESTClient("http://localhost:8080")
results = client.query(subject="?", limit=10)
Transform massive textual and structured data into facts using built-in ingestion tools
# Bulk load from RDF/Turtle files
./tools/build/bin/odb_load ./database data.ttl
# Convert text to facts via API
# Tools available for documents, code, and domain knowledge
Human-in-the-loop UI for reviewing, verifying, and correcting extracted facts before deployment
# Launch the verification UI
./tools/build/bin/odb_ui ./database
# Web interface for fact validation
# Review, edit, and approve ontology facts
Explore the full documentation with 44+ guides, examples, and API references
Everything you need from quick starts to advanced tuning
Comprehensive 16-page professional brochure covering capabilities, architecture, and use cases
5-minute tutorials to get you building with FluxDB
Complete API documentation for all interfaces
Industry whitepapers and implementation guides
Join developers building the next generation of AI-powered applications with FluxDB
Have questions about FluxDB? Need enterprise support? Our team is here to help.
Within 24 hours
Available for production deployments