PRECISO Supply Finder

Turn scattered supplier reports, BOMs, contracts, and company docs into an evidence-backed supply graph. Trace hidden dependencies across companies, facilities, components, and products.

Comment

Inspiration

Supply-chain data almost never lives in one neat, centralized database.

Supplier reports might be stored in one folder, bills of materials in spreadsheets, facility details inside PDFs, contracts somewhere else, and product dependencies scattered across several documents.

So the real challenge is not that the data does not exist. It is that the relationships between all of those pieces are fragmented.

That led us to build PRECISO Supply Finder around one simple idea:

What if you could drop a collection of supply-chain documents into one place and automatically reconstruct the network hidden inside them?

What it does

PRECISO Supply Finder turns scattered supply-chain documents into an evidence-backed knowledge graph that users can explore through natural-language questions.

Users can upload sources such as:

  • supplier reports
  • bills of materials
  • contracts
  • sourcing documents
  • company reports
  • structured CSV or JSON files

The AI processes each source independently and identifies important supply-chain entities, including:

Company → Facility → Component → Product

It then extracts relationships between those entities, for example:

Company --OPERATES--> Facility

Facility --MANUFACTURES--> Component

Component --USED_IN--> Product

Before any of these relationships become part of the graph, they are validated.

Once the graph has been built, users can ask questions like:

Which products depend on this component?

Which facilities are connected to this company?

Can you trace the path from this manufacturer to the final product?

What source proves this relationship?

PRECISO answers using the graph itself and provides the underlying evidence supporting the result.

How we built it

The system is built around three main layers.

1. AI extraction

Claude reads the uploaded documents and transforms unstructured supply-chain information into structured entities, relationships, and supporting evidence.

Importantly, every source creates its own extraction artifact. This allows us to preserve provenance instead of blending information from different documents into one opaque result.

2. LangGraph orchestration

We use LangGraph to coordinate the full agent workflow:

Read → Extract → Validate → Repair → Approve → Ingest → Query → Answer

Validation is a key part of this process.

If an extraction contains an error, the agent receives the exact validation failure and repairs only the incorrect section rather than regenerating the entire extraction from scratch.

Even after validation succeeds, the data is not immediately written to the graph. Human approval is required before ingestion.

3. PRECISO GraphRAG

Once approved, the extracted information is passed into our PRECISO GraphRAG engine.

PRECISO handles:

  • schema validation
  • entity and relationship merging
  • NetworkX graph persistence
  • semantic embeddings
  • vector retrieval
  • evidence storage
  • graph traversal
  • grounded GraphRAG queries

For local semantic search, we use Ollama with mxbai-embed-large, which generates 1024-dimensional embeddings.

The graph, embeddings, and evidence layer can all run locally.

Evidence-first design

One of our biggest design goals was making sure the LLM could not simply treat its own generated output as truth.

Because of that, the architecture deliberately separates:

AI proposal

from

validated graph knowledge

Claude proposes candidate entities and relationships, but PRECISO validates them before they are allowed to modify the graph.

Every relationship in the graph also maintains a link back to the original evidence that supports it.

This means the system can clearly distinguish between:

  • facts directly stated in a source;
  • relationships that have been validated and stored in the graph;
  • conclusions derived by traversing multiple graph relationships.

That distinction makes the final answers far more transparent and auditable.

Challenges we faced

One of the hardest problems was getting multiple independent documents to converge into a single, reliable graph.

The same company, facility, or component can appear across several sources with slightly different names or surrounding context. We needed stable entity identifiers that would let PRECISO recognize and merge those references without losing the evidence associated with each individual source.

Another challenge was making the agent workflow safe.

An LLM can easily generate JSON that is structurally correct while still proposing a relationship that makes no sense within the supply-chain schema. To handle this, we added a non-mutating PRECISO validation stage and a bounded repair loop that catches and corrects problems before anything reaches the graph.

We also wanted the application to feel genuinely agentic rather than hiding everything behind a generic loading spinner.

LangGraph execution events are streamed directly to the browser, allowing users to see real stages such as reading, extracting, validating, repairing, querying, and grounding as they happen.

Accomplishments

We are especially proud that PRECISO Supply Finder can:

  • extract supply-chain relationships from multiple independent documents;
  • preserve a separate extraction artifact for every source;
  • identify and merge shared entities across documents;
  • validate relationships before modifying the graph;
  • surgically repair invalid extraction data;
  • require human approval before ingestion;
  • build a persistent local supply-chain knowledge graph;
  • use real semantic embeddings for retrieval;
  • connect graph relationships back to their source evidence;
  • answer conversational questions using graph-grounded context;
  • stream the live agent workflow directly in the browser.

What we learned

Building PRECISO reinforced something important for us: GraphRAG becomes much more interesting when the graph does not already exist.

The difficult part is not querying a perfectly structured knowledge graph.

The difficult part is taking messy, fragmented, real-world information and turning it into graph structure that can actually be trusted.

We also saw how well probabilistic AI and deterministic systems can complement each other:

LLMs understand messy documents.

Graphs preserve relationships and structure.

Validation protects the integrity of the graph.

Evidence keeps every answer accountable.

Together, those pieces make it possible to use AI without asking users to blindly trust what the model produces.

What's next

PRECISO Supply Finder currently models the core chain:

Company → Facility → Component → Product

Next, we want to expand the ontology to include concepts such as:

  • suppliers
  • raw materials
  • warehouses
  • ports
  • regions
  • shipments
  • contracts
  • risk events
  • alternative suppliers

We also plan to introduce deterministic upstream and downstream dependency traversal, stronger temporal reasoning, improved PDF and table extraction, and richer interactive graph visualizations.

The long-term goal is straightforward:

Turn fragmented enterprise documents into a supply chain that people can actually search, trace, verify, and understand.

Built With

  • anthropic
  • claude
  • fastapi
  • graphrag
  • javascript
  • knowledge-graph
  • langgraph
  • llm
  • mcp
  • mxbai-embed-large
  • networkx
  • ollama
  • python
  • react
  • sse
  • vector
Share this project:

Updates

Submission history