MCP server
Agents discover your concepts and rules, run reasoning and fetch explanations through Model Context Protocol. Access is scoped to what each user can see.
MCP docs →Run the data processing your AI needs on the system that keeps you in charge.
Trusted by technical leaders in regulated enterprises
Graph platforms can’t distribute workloads across machines, so you’ll spend more on bigger servers
They only handle nodes and edges, so you’ll need other tools for the rest of the workflow
Copying data into a dedicated graph database requires money, migration, and maintenance.
Our living knowledge graph augments itself by deducing hidden knowledge. We don’t just look at what the data says — we derive new facts from existing information.
“Prometheux is more than just technology; it is a catalyst for fact-based decision-making. The ability to query heterogeneous databases through a flexible ontology makes it possible to infer deep knowledge and automate complex tasks, delivering trustworthy insights that far exceed the capabilities of traditional systems.”
Anna FavaSenior Manager, Data & AI · Dompéstake(X,Y,S) <- own(X,Y,S). stake(X,Y,S) <- controls(X,Z), own(Z,Y,S). total(X,Y,T) <- stake(X,Y,S), T = msum(S). controls(X,Y) <- total(X,Y,T), T > 0.5.
+ controls(HoldCo, Alba)60% held directly
+ controls(HoldCo, Borea)30% direct + 30% through Alba, which it controls
Write in any language: Python, Cypher, Vadalog, Datalog, SQL, natural language, and more. Query tables as graphs, graphs as tables, or any combination — all in one place. Data never gets locked in again.
See how we handle ontologies >>“Prometheux’s research-backed platform abstracts away our various data sources, letting us iterate quickly […] instead of writing complex database queries or migrating data. […] The explain functionality […] is extremely valuable in the financial sector where audit trail and logical transparency is of very high priority.”
depends_on(P,S) <- supplies(S,P). depends_on(P,S) <- depends_on(P,M), supplies(S,M). at_risk(P) <- depends_on(P,S), disrupted(S), not second_source(P).
WITH RECURSIVE depends_on AS (SELECT plant, supplier FROM supplies UNION SELECT d.plant, s.supplier FROM depends_on d JOIN supplies s ON s.plant = d.supplier) SELECT DISTINCT plant FROM depends_on JOIN disrupted USING (supplier) WHERE plant NOT IN (SELECT plant FROM second_source);
MATCH (s:Supplier {disrupted: true})-[:SUPPLIES*1..]->(p:Plant) WHERE NOT (p)<-[:COVERS]-(:SecondSource) RETURN DISTINCT p.name AS plant
hit = depends_on.merge(disrupted, on="supplier") covered = hit.plant.isin(second_source.plant) at_risk = hit[~covered][["plant"]].drop_duplicates()
Which plants are at risk if a supplier at any tier is disrupted, unless an approved second source covers the part?
✓ 3 rows · same result in Logic
| plant | via |
|---|---|
| Lyon | Fastenix → Kora Steel |
| Turin | Kora Steel |
| Gdańsk | Fastenix → Kora Steel |
Distribute and parallelize graph traversal and data processing at peak efficiency and lower cost. Our proprietary engine handles sub-second queries and petabyte-scale processing.
See our benchmarks >>“With Prometheux, we achieved a speed-up of over 250% on critical tasks involving complex reasoning over knowledge graphs with hundreds of millions of nodes and billions of edges.”
Deploy anywhere, and never get locked into a specific database, cloud, or AI model. Your knowledge graphs stay portable and run on Snowflake or Databricks.
“Prometheux enabled us to build a system that can access our databases, process all the client’s historical variables, and provide an intelligent, understandable explanation autonomously.”
Massimiliano MalinHead of Credit Risk · Banca SellaConnect your data, encode your rules and trace every answer, then put it to work in apps and agents. All in one place, on your infrastructure.
Click any tab, or let it play.
Which plants are at risk if Kora Steel halts output?
prometheux · reason at_risk
3 plants are at risk.
Same question, same answer, every time.
supply_risk5 tables6 columns · read in place
supplier_idstringnamestringcountrystringtierintrisk_scorefloatupdated_attimestamp6 columns · read in place
part_idstringsupplier_idstringplant_idstringqtyintunit_costdecimalvalid_fromdate5 columns · read in place
plant_idstringcitystringcountrystringcapacityintopeneddate4 columns · read in place
part_idstringalt_supplier_idstringlead_time_daysintapprovedbool5 columns · read in place
supplier_idstringcert_typestringissuerstringissueddateexpiresdateQuery tables as a graph, or graphs as a table, in any combination. No data movement.
1% A plant is at risk if a supplier at any tier is disrupted, 2% unless an approved second source covers the part. 3depends_on(P,S) <- supplies(S,P). 4depends_on(P,S) <- depends_on(P,M), supplies(S,M). 5at_risk(P) <- depends_on(P,S), disrupted(S), not second_source(P).
✓ 3 rows · same result in every language
| plant | via |
|---|---|
| Lyon | Fastenix → Kora Steel |
| Turin | Kora Steel |
| Gdańsk | Fastenix → Kora Steel |
1WITH RECURSIVE depends_on AS ( 2 SELECT plant, supplier FROM supplies UNION 3 SELECT d.plant, s.supplier FROM depends_on d 4 JOIN supplies s ON s.plant = d.supplier) 5SELECT DISTINCT plant FROM depends_on JOIN disrupted USING (supplier) 6WHERE plant NOT IN (SELECT plant FROM second_source);
✓ 3 rows · same result in every language
| plant | via |
|---|---|
| Lyon | Fastenix → Kora Steel |
| Turin | Kora Steel |
| Gdańsk | Fastenix → Kora Steel |
1MATCH (s:Supplier {disrupted: true})-[:SUPPLIES*1..]->(p:Plant) 2WHERE NOT (p)<-[:COVERS]-(:SecondSource) 3RETURN DISTINCT p.name AS plant
✓ 3 rows · same result in every language
| plant | via |
|---|---|
| Lyon | Fastenix → Kora Steel |
| Turin | Kora Steel |
| Gdańsk | Fastenix → Kora Steel |
1def at_risk(depends_on, disrupted, second_source): 2 hit = depends_on.merge(disrupted, on="supplier") 3 covered = hit.plant.isin(second_source.plant) 4 return hit[~covered][["plant"]].drop_duplicates()
✓ 3 rows · same result in every language
| plant | via |
|---|---|
| Lyon | Fastenix → Kora Steel |
| Turin | Kora Steel |
| Gdańsk | Fastenix → Kora Steel |
✓ 2 notes pinned · read by at_risk and by every agent
1% Explain each at-risk plant for the operations team. 2% Input: at_risk(plant, via). Output: plant, explanation. 3Explain in one sentence why {plant} is at risk, 4naming the supplier chain {via}. Plain language, no jargon.
✓ 3 rows · one explanation per at_risk plant
| plant | explanation |
|---|---|
| Lyon | Buys from Fastenix, which depends on Kora Steel. |
| Turin | Buys directly from Kora Steel, with no approved second source. |
| Gdańsk | Buys from Fastenix, which depends on Kora Steel. |
Natural language
A plant is at risk if a supplier at any tier is disrupted, unless an approved second source covers the part. Tiers are counted through the bill of materials.
The notes this concept reads, and every agent sees.
Session
Tasks 92% complete
| plant | via | tier |
|---|---|---|
| Lyon | Fastenix → Kora Steel | 2 |
| Turin | Kora Steel | 1 |
| Gdańsk | Fastenix → Kora Steel | 2 |
Natural language
Fields
✓ at_risk traced back through 4 concepts to 3 sources
10 nodes · 9 relationships · read in place
| node | type | score |
|---|
| plant | exposure | status |
|---|---|---|
| Lyon | tier 2 · Fastenix | At risk |
| Turin | direct | At risk |
| Gdańsk | tier 2 · Fastenix | At risk |
Exposure graph
✓ Live for your team · web app, API and MCP
Business users get the same answers as your agents.
In regulated industries, AI must be reliable, governed and has to integrate seamlessly within existing systems to get to work, fast.
1% Ownership ontology · defined once, reused everywhere 2controls(X,Y) :- owns(X,Y,S), S > 0.5. 3controls(X,Z) :- controls(X,Y), controls(Y,Z). 4flag(C) :- controls(S,C), sanctioned(S). 5 6% sources 7@bind("owns", "snowflake", "kyc.shareholders"). 8@bind("sanctioned", "s3", "sanctions/sdn_list.csv").
The flag rule already exists in ownership.rules, so the job only schedules it and writes the output.
Three active suppliers are controlled by Eastline BV, directly or through subsidiaries. Together they make up 18% of Q3 spend.
| Supplier | Control path | Q3 spend |
|---|---|---|
| Nordhavn Capital | Eastline → Nordhavn | €4.2M |
| Halden Components | Eastline → Nordhavn → Halden | €2.9M |
| Vireo Freight | Eastline → Vireo | €1.1M |
Agents discover your concepts and rules, run reasoning and fetch explanations through Model Context Protocol. Access is scoped to what each user can see.
MCP docs →Call the same knowledge graph from services, notebooks and pipelines over REST or Python. One definition serves apps and agents alike.
API docs →Stream results, inspect query plans and open derivations without leaving the terminal. Coding agents call it directly, with no server to set up.
CLI docs →Extract, transform, load
Business logic in queries and scripts
Export, model, load
Another vendor store to run

Graph logic in another language
Map both into RDF, model it in OWL, query it in SPARQL





Hand-built to merge answers that can disagree
Locked in. Your graph and semantic data live in vendor stores. Leaving means another migration.
Graph, SQL, business context and rules, in one fully portable layer.
Builds your model and rules from natural language, and suggests relationships to speed things up. You review.
Graph and BI
Back into your apps
Run workflows deterministically
Enterprise & complex deployments
Work closely with our Forward Deployed Engineers, from months to days.
Bring us one critical workflow. We map your data, rules and exceptions with your team, then run it on your infrastructure.
No. It’s a knowledge graph platform with its own reasoning engine. You query your existing data as a graph without building one or copying it into a separate store.
No. Prometheux connects to SQL databases, NoSQL stores, data lakes, REST APIs and more, and processes data where it lives. No migration, no duplicate copy to keep in sync.
Wherever you need it: on your premises, in your own AWS, Azure or GCP account, as a native app on Snowflake or Databricks, or as SaaS, fully managed by Prometheux.
You or an agent define concepts, relationships and logic once, in plain language or code, as reusable rules that run across all your connected data. You review every rule, and our engineers can help with the first ones.
A graph database needs its own copy of your data, kept in sync. A semantic layer gives your metrics consistent definitions. Prometheux queries the data you already have as a graph, and your business rules derive what no table stores, like which supplier a plant depends on three tiers down. Every answer is deterministic and comes with its explanation.
Yes. Prometheux is SOC 2 Type II audited, and we’ll share the report on request. Deploy it where your data has to stay, including fully on-prem. Each user’s storage is isolated, agents act with the user’s own access rights, and every result can be followed back through the concepts and sources it depends on.
Through MCP, the API or the CLI. Agents query your knowledge graph and get answers they can explain, instead of guessing from raw tables.