The trust layer for industrial product data.
Turn supplier PDFs, spreadsheets, scans, and feeds into clean product records
that your team can verify, defend, and publish with confidence.
Why Truvo · How it works · What you get · Run locally · Talk to us
Truvo includes a challenge-specific workflow for the official UniHack data contract:
6-field CSV/XLSX input
→ dynamic identity, category, attribute and UOM processing
→ evidence-backed description construction
→ review warnings for unsupported facts
→ exact 252-header XLSX/CSV delivery file
Open Imports and use the UniHack Evaluation Pipeline panel. It accepts renamed, reordered, or modified input files; validates the six mandatory columns; processes every row from its values; previews field lineage; and exports all 252 official headers without renaming or reordering them.
The repository currently includes the two files supplied through the official portal:
Unihack_ Sample Dataset - Input.csv: 1,000 rows and six input fields.Unihack_ Expected Output - Delivery Format.csv: the 252-column contract and two completed examples.
The two example products are regression references, not a statistically meaningful accuracy benchmark. Truvo does not contain MPN-, filename-, or row-number-specific output overrides. Unknown facts remain blank or are marked for review.
Run the evaluation-contract tests with:
npm run test:unihackThese tests process all 1,000 official input rows, assert exact header order, exercise unseen product numbers and changed values, reject missing mandatory columns, filter portal placeholders, and verify quoted CSV round-tripping.
For selected high-value rows, the preview can also search official manufacturer sources using an OpenAI → Gemini → Anthropic failover chain. The order is configurable. Failover occurs for unavailable keys, quota/authentication errors, timeouts, or invalid provider responses—not when a successful search finds no verified evidence. Candidates are cached and rate-limited, retailer domains are rejected, and every value requires a validated manufacturer-domain citation plus explicit reviewer approval. Approved candidates are carried into CSV/XLSX using a signed, expiring approval token; arbitrary browser-supplied overrides are not accepted.
Generate the transparent, reproducible scorecard with:
npm run report:unihackSee the current UniHack evaluation report. It separates the small team-labelled regression from the two official examples and reports unsupported rows and blank fields instead of hiding them.
Presentation resources:
- Three-minute demonstration
- Pitch outline
- Pitch deck PDF
- Architecture diagram
- Submission draft
- Submission checklist
- Four-row demo input
- Generated exact-contract demo workbook
Industrial product information arrives in every shape imaginable: a scanned datasheet, a supplier workbook, an old ERP export, or a feed with unfamiliar field names.
Teams spend hours copying values, fixing units, finding duplicates, and deciding which source to trust. Important details are often lost along the way. When a customer, engineer, or auditor asks where a value came from, the answer can be difficult to prove.
Truvo gives that work one clear home.
It reads incoming files, cleans the data, shows conflicts, and keeps every important value linked to its source. Your team reviews the choices that need a person. The approved record can then move to your PIM, ERP, online store, APIs, and AI tools.
Move faster without losing the truth.
| Without Truvo | With Truvo |
|---|---|
| People copy specifications by hand | Files become structured records through one import flow |
| Supplier terms and units do not match | Labels and measurements are normalized consistently |
| New files silently replace old values | Verified values are protected and changes are visible |
| Conflicts live across emails and spreadsheets | Competing values appear together for review |
| Teams cannot explain where a number came from | Values stay linked to their source, page, row, or cell |
| Clean data is rebuilt for every destination | One approved record can serve every business system |
Truvo is for manufacturers, distributors, catalog teams, product experts, and B2B commerce teams that cannot afford hidden product-data errors.
A valve supplier sends three files.
- A PDF says the maximum pressure is 600 psi.
- A spreadsheet says it is 500 psi.
- An old ERP export has no pressure value.
A normal import may pick one value and hide the rest. Truvo does not do that.
Truvo keeps both values, shows the conflict, and links each value to the exact file and location where it was found. A product expert can compare the sources and approve the right value. The choice, the person, the time, and the reason stay in the record.
That same approved value can then be used by the website, sales team, PIM, ERP, and API.
Test Truvo with one of your files →
flowchart LR
A["PDFs · scans · spreadsheets · feeds"] --> B["Extract and structure"]
B --> C["Normalize and compare"]
C --> D["Review with the source"]
D --> E["Approved product record"]
E --> F["PIM · ERP · commerce · APIs"]
Upload technical PDFs, scanned documents, XLSX workbooks, or CSV files. Truvo keeps the original source attached to the import.
The processing pipeline finds product details, maps different supplier labels to one standard name, fixes units, groups products by industry standard, and looks for duplicates.
Values that are hard to read, source conflicts, odd values, missing fields, and possible duplicates move into one review list. Reviewers see the suggested value beside its source.
Approved records keep their source history. They can be exported, sent to connected systems, or shared through APIs.
Truvo is not only a file reader. It is not only a PIM. It is not only an AI tool.
| Tool | What it does well | What Truvo adds |
|---|---|---|
| AI file reader | Pulls text and values from files | Source proof, conflict checks, review, and history |
| Spreadsheet or ETL tool | Moves and changes data | Product rules, human approval, and a clear review queue |
| PIM | Stores and publishes product data | Cleans messy source data before it enters the PIM |
| Data quality tool | Finds empty or invalid fields | Shows the source, competing values, and the full reason for a choice |
Truvo can sit between messy supplier data and the systems your business already uses. You do not need to replace everything to start.
- Import PDF, XLSX, CSV, and scanned product documents.
- Read native text and use vision-assisted extraction when configured.
- Track import progress, failures, and items that need review.
- Preserve the original document and extraction location.
- Map terms such as
OAL,Overall Length, andDim Lto one standard field. - Normalize length, weight, pressure, temperature, electrical, and mechanical units.
- Learn your company’s own terms from reviewer choices.
- Match products to industrial standards and check which fields are missing.
- Compare values from multiple suppliers in one place.
- Set clear rules for small and large value differences.
- Protect human-verified values from silent replacement.
- Record approvals, edits, rejections, and reversions in history.
- Find possible duplicates by using part numbers, names, brands, and product details.
- Match supplier and distributor catalogs to internal SKUs.
- Group product families and suggest safe values for missing fields.
- Monitor stale specifications, certifications, and upstream changes.
- Export approved catalog data as CSV or JSON.
- Connect PIM, ERP, and commerce systems.
- Create limited API keys for product data and source proof.
- Share updated product feeds and JSON-LD product records.
Upload the supplier’s files as they are. Truvo reads the fields, fixes names and units, finds missing details, and sends only the hard choices to your team.
Find duplicate SKUs, mixed units, weak descriptions, missing fields, and values that no longer match the source.
Put supplier values side by side. Use source rules and expert review to choose the right one without losing the other evidence.
Set checks for old values and expiring certificates. Run a sweep to find records that need a new review.
Give websites, search tools, buying agents, and APIs a clean record with source proof instead of raw supplier text.
Technology can automate the repetitive work. It should never hide the truth from the people responsible for it.
- Never hide the source. Important values stay connected to their evidence.
- Never present a suggestion as a fact. Inferred and unconfirmed values are clearly identified.
- Never silently overwrite approved data. New values become visible alternatives when they disagree.
- Never hide a conflict. Truvo surfaces differences instead of quietly choosing one.
- Never claim certainty without support. Confidence reflects the available evidence.
- Keep a full history. Important changes record what happened, when, and why.
- Keep people in control. Your organization decides what can be automated and what needs approval.
Truvo supports workflows across technical product categories, including:
- Electrical equipment and lighting
- HVAC and climate control
- Plumbing and industrial piping
- Fasteners and industrial hardware
- Bearings and power transmission
- Fluid control and industrial actuation
The platform can map products to standards such as ETIM, eCl@ss, UNSPSC, DIN, ISO, and ASME.
| Workspace | What it helps you do |
|---|---|
| Overview | See catalog completeness, verification rates, and open work |
| Catalog | Search and inspect approved product records |
| Imports | Bring in files and follow processing progress |
| Review | Resolve conflicts, uncertain values, and duplicates with evidence |
| Cross-catalog matching | Connect external supplier SKUs to internal products |
| Supplier intelligence | Understand which sources are reliable over time |
| Drift monitor | Find stale or changed specifications before they become problems |
| Quality tuning | Improve auto-approval rules by learning from past reviews |
| Rules and access | Set validation rules, roles, and category permissions |
| Discovery API | Give trusted product records to machines and agents |
| Syndication hub | Send approved data to connected business systems |
| Team | Value |
|---|---|
| Catalog team | Less copy and paste, fewer repeated fixes, and one place to work |
| Product expert | The source and competing values in the same review screen |
| Data leader | Clear quality numbers, supplier scores, rules, and change history |
| Sales and support | Product answers that can be checked against a real source |
| Engineering and compliance | Better control over technical values and old certificates |
| Developers | Clean exports, API keys, JSON-LD records, and update feeds |
This repository includes working code and test data for the main Truvo flow.
- Sample PDFs, a scanned sheet, CSV files, and supplier workbooks are in
fixtures/. - The acceptance script covers sign-up, imports, product data, matching, supplier scores, drift checks, APIs, and quality rules.
- Browser tests cover the main user flow with Playwright.
- The Prisma schema shows how sources, values, conflicts, reviews, history, rules, keys, and integrations are stored.
- The API code includes the routes used by the workspace.
We do not use made-up customer numbers in this README. The best test is your own file and your own rules.
Truvo can return product data in a format that people and machines can read. The example below is short, but it shows the key idea: the value and its proof travel together.
{
"@type": "Product",
"sku": "70-104-01",
"name": "Bronze Ball Valve",
"manufacturer": {
"name": "Apollo Valves"
},
"additionalProperty": [
{
"name": "Maximum pressure",
"value": "600 psi",
"status": "verified",
"confidence": 0.96,
"provenance": {
"sourceId": "source-id",
"sourceLocation": "Page 3, Table 2, Row 4",
"extractionMethod": "text_parse"
}
}
],
"auditHash": "record-check-hash"
}The Discovery API also supports product search, single-product records, and update feeds. API keys can be limited by purpose and can be removed when they are no longer needed.
Truvo is a TypeScript monorepo with separate web, API, and processing services.
flowchart TB
UI["React workspace"] --> API["Express API"]
API --> DB["Prisma data model"]
API --> Q["Redis · BullMQ"]
Q --> W["Processing worker"]
W --> DB
W --> FILES["Source document storage"]
API --> OUT["Exports · integrations · discovery APIs"]
| Layer | Technology |
|---|---|
| Web application | React, TypeScript, Vite, Tailwind CSS |
| API | Express, TypeScript, JWT authentication |
| Processing | BullMQ workers, rule-based parsers, optional Anthropic-assisted extraction |
| Data | Prisma with PostgreSQL |
| Queue | Redis |
| Tests | Playwright and an end-to-end acceptance script |
Does Truvo replace our PIM?
Not always. Truvo can clean, check, and approve data before it reaches your PIM. It can also send approved records to other systems. You can start without replacing the tools you already use.
Does the AI make the final choice?
No. Truvo can suggest and sort work, but your rules decide what can pass on its own. Important or unclear choices can be sent to a person. Reviewers can approve, edit, reject, or undo a change.
Do we need an AI key to try it?
No. An Anthropic API key is optional. Parts of the import flow can use the rule-based path without it. An AI key adds text and vision help where the worker supports it.
Can Truvo use our company rules?
Yes. Teams can set required fields, source choices, value limits, approval levels, and user access. Rules can be limited to a product group or field.
Can we trace a value back to the file?
Yes. The data model stores the source, method, and source location for product values. The review screen is made to show the value beside this proof.
Is this ready to place on a public server?
The repository contains the working web app, API, worker, data model, and tests. Before a live launch, your team should review hosting, secrets, backups, file storage, network rules, monitoring, and legal needs. Truvo gives you the product base; production safety still needs a real launch review.
- Node.js 20 or newer
- npm
- Redis running on
localhost:6379
An Anthropic API key is optional. Without one, the worker uses its offline rule-based extraction path where supported.
git clone <your-repository-url>
cd truvo
npm installcp .env.example .envFor local development, keep Redis available. Replace all sample secrets before using Truvo outside your own computer.
npm run prisma:generate
npx prisma migrate dev --name init
npm run seedOpen three terminals from the repository root:
# Terminal 1
npm run dev:api
# Terminal 2
npm run dev:worker
# Terminal 3
npm run dev:webThen open http://localhost:5173.
| Variable | Required | Purpose |
|---|---|---|
REDIS_URL |
Yes | Redis connection used by the API and worker queues |
JWT_SECRET |
Yes | Signs user sessions; use a strong private value |
UPLOAD_DIR |
No | Location used to store incoming source documents |
OPENAI_API_KEY |
No | First optional provider for official-source search |
OPENAI_MODEL |
No | OpenAI Responses API model used for source search |
GEMINI_API_KEY |
No | Second optional provider for grounded source search |
GEMINI_MODEL |
No | Gemini model used for grounded source search |
ANTHROPIC_API_KEY |
No | Enables Anthropic-assisted text and vision processing |
ANTHROPIC_MODEL |
No | Anthropic model used for classification and official-source search; defaults to claude-sonnet-4-6 |
SOURCE_PROVIDER_ORDER |
No | Comma-separated source-search fallback order; defaults to openai,gemini,anthropic |
UNIHACK_SOURCE_CACHE_DIR |
No | Persistent cache for cost-controlled manufacturer searches |
PORT |
No | API port; defaults to 3000 |
npm run dev:api # Start the API
npm run dev:worker # Start the processing worker
npm run dev:web # Start the web application
npm run prisma:generate # Generate the Prisma client
npm run seed # Add starter taxonomy and demo data
npm run test:unihack # Verify the exact challenge contract and safety rules
npm run report:unihack # Regenerate the transparent evaluation report
npm run test:unihack:api # Verify a running stack's preview and downloads
npm run test:acceptance # Run the API acceptance flow
npm run test:unihack # Verify the 1,000-row UniHack data contract
npm test # Run Playwright end-to-end tests
npm run build --workspace webtruvo/
├── api/ Exp
6096
ress API, authentication, and product-data endpoints
├── worker/ Imports, normalization, classification, and quality jobs
├── web/ Customer-facing site and authenticated React workspace
├── prisma/ Data model and seed data
├── fixtures/ Sample PDFs, spreadsheets, and catalog files
├── tests/ Browser and UniHack contract tests
├── UniHack/ Official portal input and delivery-format files
├── scripts/ Acceptance verification
└── WINNING_PLAN.md UniHack implementation and submission plan
Truvo includes password hashing, signed sessions, user roles, limited API keys, source history, and change records.
Admins can manage rules and access. Managers can guide data work. Reviewers can handle product choices. Contributors can bring in source data. Access can also be limited by product group.
These tools are a strong base. Your company must still review hosting, backups, network safety, secrets, and legal needs before a live launch.
The best way to understand Truvo is to start with the supplier file your team dislikes most.
Bring one PDF, workbook, scan, or catalog export. See what can be structured automatically, what needs review, and whether every accepted value can still be traced back to its source.
When you test Truvo, ask five simple questions:
- Can we upload the file without rebuilding it first?
- Did Truvo find the product details that matter to us?
- Can we see where each value came from?
- Are conflicts and weak values easy to review?
- Can the approved record move to the systems we use?
Ready to turn product-data chaos into records you can trust?
Talk to the Truvo team
TRUVO
Product data you can prove.