
Following a Real LPG Tax Hoax Through Pehchaan AI
How I built a graph-powered investigation system—and what a believable forwarded message revealed about it.
Following a Real LPG Tax Hoax Through Pehchan AI
How I built a graph-powered investigation system, and what a believable forwarded message revealed about it.
A real LPG-tax hoax provides a practical walkthrough of Pehchan's retrieval, graph exploration and evidence handling.
- What it is An investigation workbench for forwarded claims, built on a FalkorDB knowledge graph of published fact-checks
- Data 11,758 ClaimReview fact-checks · 11,623 claim wordings · 184 publishers · 69 entities · 14 narrative frames · 8 topics
- Retrieval Multilingual MiniLM embeddings in FalkorDB's native vector index
- Relevance English DeBERTa NLI, checked in both directions
- Agent model GPT-OSS 20B via OpenRouter, low reasoning effort, bounded tool calls
- Interfaces Web app · CLI · Streamable HTTP MCP
- Links Live app · Code · Public MCP endpoint
The numbers made the message worth checking
The message offered an explanation for an expensive cooking-gas cylinder.
According to its price breakdown, state governments charged a 55% tax, while the central government charged only 5%. It presented individual costs and assigned responsibility for the final price.
A reader could encounter this as a neatly formatted calculation rather than an obviously fabricated story. Checking it requires more than deciding whether the headline sounds believable.
Publishers examined the allegation in July 2021. Their reviews explained that the tax breakdown was incorrect: at the time, domestic LPG attracted 5% GST, divided equally between the Centre and states. That historical finding belongs to the dated reviews; it should not be presented as an independently checked statement about today's tax rules ( Newschecker's investigation ). The same allegation resurfaced and was reviewed again in 2025 ( Manorama's 2025 review ).
For me, this was a useful example of the problem Pehchan should address.
Could it locate the reviewed allegation? Could it preserve the publisher's evidence and date? Could it distinguish that specific tax claim from other messages about LPG prices?
And could it show how the claim connects to a broader set of reviewed narratives without treating every related article as proof?

The viral message used a detailed price breakdown to support an incorrect allegation about LPG taxation. (Image: [publisher name], linked above.)
What I wanted Pehchan to produce
I built Pehchan AI for journalists, fact-checkers and researchers investigating forwarded claims.
The output I wanted was an inspectable investigation:
- The submitted wording.
- Previously reviewed claims that might match.
- Original publisher ratings and source links.
- Relevant graph connections.
- An explanation of uncertainty.
- A clear next action.
These requirements became three investigation outcomes:
Outcome | Meaning |
|---|---|
Evidence dossier ready | Relevant recorded reviews have been assembled |
Human review needed | Relevance, scope or source context needs interpretation |
Evidence is insufficient | The graph does not contain sufficiently relevant recorded evidence |
Alongside the status, every report carries a finding that classifies the message itself: a known recycled claim (a direct publisher review exists), a variant of a known narrative (only related reviews were reached), or a new claim (queued for a human with high priority).
A publisher's rating and Pehchan's workflow status remain separate.
For example, a publisher may have rated a reviewed allegation false, while Pehchan still requests human review because the submitted message differs materially from it.
That separation shaped the implementation from the beginning. The application, not the model, chooses the case status and every citation.
I built the evidence pipeline first
My first milestone was data ingestion and graph validation.
Before introducing an LLM, I wanted to prove that the application could ingest a genuine review, retrieve its original fields, and explain its recorded relationships.
Pehchan uses structured ClaimReview markup from the Google Fact Check Markup Tool / Data Commons feed. The records include reviewed wording, ratings, source URLs, dates and available publisher information. The linked article bodies remain on publishers' websites ( dataset information ).
The pipeline follows these stages:
Saved source feed
↓
Stream and select records
↓
Normalize fields and assign stable identities
↓
Audit invalid records, duplicates and conflicts
↓
Validate prepared records
↓
Merge into FalkorDB
↓
Validate evidence retrieval and graph structureI began with a small seed covering historical claims about vaccines, 5G, climate and moon landings. That made individual records and query results manageable to inspect.
Event subsets followed (the LPG crisis, the CJP protest, the Iran and Russia-Ukraine wars), and then every review in the public feed dated 2025 or 2026: 11,392 reviews after de-duplication, with 18 rating conflicts audited and skipped rather than silently merged. The collection now holds 11,758 fact-check records, 11,623 claim wordings and 184 publisher records in the documented October 2026 build.
Several decisions mattered:
Normalization had to preserve meaning. Numbers and negation could not disappear during cleaning. For a claim built on "55%" versus "5%", that is the whole allegation.
Identities had to be stable. Reimporting a record should not create another copy merely because the pipeline ran again. Wordings get SHA-256-derived IDs from their text and language; reviews are keyed on the canonical review URL, the reviewed claim and the language.
Ratings had to remain source-derived. I retained publishers' original rating strings and rating objects.
Provenance had to survive ingestion. Records retain their original markup, source-file hash and record position. The FACTLY review in this walkthrough, for example, still points back to record 70,244 of the Data Commons feed file, with that file's SHA-256 stored beside it.
These choices follow the source-preservation and validation decisions recorded in the project's decision register .

Reliable evidence retrieval begins with preserving and validating the source records.
Why the graph separates wording, reviews and context
A claim can have multiple wordings. Multiple publishers can review the same wording. Different claims can mention the same entity without making the same allegation.
I represented those distinctions explicitly.
Node | What it represents |
|---|---|
ClaimVariant | A recorded claim wording |
Claim | Conservative normalized-text grouping |
FactCheck | A publisher's review record |
Publisher | Attribution for that review |
Entity | A mentioned person, organization, place or concept |
NarrativeFrame | An annotated recurring pattern |
Topic | A subject grouping |
Investigation | A saved investigation snapshot |
Submission | A submitted wording retained for recall |
The central relationships are:
FactCheck ──CHECKS──\> ClaimVariant ──EXPRESSES──\> Claim
│ │
└──PUBLISHED_BY──\> Publisher ├──MENTIONS──\> Entity
├──USES_FRAME──\> NarrativeFrame
└──ABOUT_TOPIC──\> TopicThe relationship's basis matters as much as its presence.
A
CHECKS relationship comes from a review record. An entity or frame relationship may come from a rule-based annotation. A saved MATCHES relationship carries a model assessment.The interface needs to preserve those differences so that a researcher can interpret what the graph actually establishes. In the graph explorer, solid lines come from source records and dashed lines are inferences. The full schema, with every identity rule, is in graph-schema.md .

The schema keeps the reviewed wording, publisher evidence and inferred narrative context distinct.
Retrieval finds a candidate. Relevance decides how to use it.
I used a multilingual MiniLM embedding model to retrieve semantically similar wordings from FalkorDB's native vector index.
That helps when a message has been translated, shortened or rewritten.
A second model, a pinned English DeBERTa checkpoint, performs natural-language inference, or NLI, to assess the relationship between the submitted message and the candidate wording.
Its assessments distinguish:
Same proposition
Contradiction
Related context
Uncertain
IrrelevantA direct match requires support in both directions: the submission has to entail the recorded wording, and the recorded wording has to entail the submission.
This is important for the LPG example. A review of a particular tax breakdown should not automatically settle every statement about cooking-gas prices.
Multilingual retrieval also has a wider operating range than the current English NLI model. The system may retrieve a promising review in another language while remaining uncertain about equivalence. Unsupported languages and overlong pairs are marked uncertain explicitly.
That uncertainty stays visible instead of becoming a confident match simply because the vector score is high.
Walking the complete LPG claim through the live application
For a reproducible run, I submitted the complete allegation, preserving both claimed tax rates:
> State governments levy 55% tax on domestic LPG cylinders while the Central government levies only 5% tax.
The deployed application returned:
Field | Observed result |
|---|---|
Finding | KNOWN_RECYCLED_CLAIM |
Investigation status | EVIDENCE_DOSSIER_READY |
Matched publisher | FACTLY |
Original publisher rating | FALSE |
Review date | 16 July 2021 |
Relevance assessment | SAME_PROPOSITION |
The source was FACTLY's review of the same state-versus-central-government tax allegation ( returned review ).
The numbers behind that match: the recorded wording came back at 0.957 cosine similarity, and the NLI model scored entailment at about 0.998 in both directions, with contradiction below 0.001 each way.
The hosted model made four tool calls:
- Find similar claims.
- Retrieve the matched claim's evidence.
- Explore its narrative graph.
- Finish the investigation.
Before the model started, the orchestrator checked graph memory for an earlier submission of this wording and found none. After the model finished, Evidence & Response re-read the cited review independently and applied the application's evidence policy.
This run used the complete recorded proposition, so it demonstrates successful lookup, evidence assembly and graph exploration for that wording. It does not, by itself, prove robust paraphrase handling.

The complete allegation matched a recorded FACTLY review; Pehchan preserved the original rating, source and date.

The investigation exposes which tools ran and which source record supported the dossier.
The graph explains what surrounds the claim
The LPG-tax review also connects to other reviewed claims through the annotated frame "Fuel prices and shortages as political weapons."
That frame is an application annotation awaiting human interpretation. It is not a publisher's factual verdict or an assertion that every connected claim has the same origin.
In the graph, I could follow the LPG-tax wording to that frame and then to other reviewed LPG-related statements, including a Fact Crescendo review of the tax allegation and separate reviews concerning attributed political or celebrity statements.
Those connections help a researcher explore the surrounding information.
They do not make every connected article evidence about the original 55% claim.
When no direct match exists, Pehchan can also widen through entities and frames tagged in the submitted message. Shared nodes are weighted by rarity, reducing the influence of broad hubs.
I added a filter preventing shared places alone from qualifying a widened hit. Mentioning the same country (India, China, Iran) was too weak a basis for connecting otherwise unrelated claims. A widened hit now needs a shared narrative frame or a shared non-place entity.
For connection paths, the implementation uses FalkorDB's native
algo.SPpaths , bounded at eight hops. It replaced an enumerate-and-sort variable-length match: the same path came back in 0.01 s instead of 2.1 s on the 641-variant graph. Native BFS supports additional graph exploration.
Shared narrative frames support exploration; related reviews remain separate from direct evidence.
Where the LLM fits
The workflow has three specialist roles:
- Claim Scout: retrieve candidates and assess relevance.
- Graph Detective: explore recorded relationships and widen context.
- Evidence & Response: validate source records and select the investigation action.
The current hosted configuration uses GPT-OSS 20B through OpenRouter, with low reasoning effort. Local models handle embeddings and NLI.
The hosted model requests tools through a bounded function-calling loop. Application code validates tool names, arguments, permitted IDs and required reads. Out-of-scope reads are refused back to the model along with what is still required, and references the application cannot confirm are dropped and listed.
It cannot execute arbitrary Cypher or directly write records. Every query is a fixed, parameterized template in code; no user input becomes a label or a query fragment.
One reliability improvement came from an unexpectedly small change: the internal search tool takes no arguments. The application already holds the submitted message, so the model does not need to reproduce it before searching.
This avoided failures where the model repeatedly rewrote a Hindi submission.
The system also discloses provider failures and offline fallback behavior. Each report records which provider answered and every failure along the way; if every hosted provider fails, the offline specialists answer and the report says so. A generated analyst note remains labeled as model commentary.
These choices are documented in the inference and orchestration sections of Decision.md and Flow.md .

Models help select operations and assess relevance; the application preserves evidence boundaries and controls persistence.
A saved investigation can become useful again
An authorized researcher can save the dossier as an investigation.
That preserves the report snapshot and links its exact cited reviews and claim variants through
EXAMINES and CITES edges. The submitted wording is also written as a Submission node, which has its own vector index.Where a direct match was established, the submission receives a
MATCHES relationship to the recorded claim variant, carrying the Scout's assessment:Investigation
└──SUBMITTED──\> Submission
└──MATCHES──\> ClaimVariantA later, near-identical submission (at least 0.95 similar to a stored one) can retrieve that stored wording and follow the established match.
Recall still embeds the incoming message and re-reads publisher evidence. When its conditions are met, it avoids fresh NLI classification and hosted-model inference. In my laptop run, a repeat forward came back in about 4 s instead of about 30 s cold.
The interface identifies this as "Answered from graph memory." The reuse of an earlier relevance assessment is also disclosed in the Scout's uncertainty note, and forcing a review bypasses recall.
This makes saving a case an action that can affect future investigations.
Read-only public dossiers can use this memory, but they never write to it.

A saved direct match can be reused through the graph when a near-identical message arrives.
Using the same investigation tools through MCP
I exposed Pehchan through Streamable HTTP MCP so that another application can use the same investigation backend.
Six public tools support read-only operations:
Tool | What it does |
|---|---|
find_similar_claims | Similar-claim retrieval with relevance assessment |
get_claim_evidence | Publisher evidence: source URLs, original ratings, provenance |
explore_narrative_graph | Narrative exploration through shared frames |
find_evidence_path | Connection paths, including entity bridges |
expand_narrative_context | Context widening through tagged entities and frames |
assemble_evidence_dossier | Dossier assembly without saving a case |
Two additional tools,
investigate_claim and create_review_case , persist investigations or explicitly requested review cases behind authorization.The read-only endpoint is public at
https://16-192-177-240.sslip.io/public/mcp/ , so it can be added as a custom connector by URL.A connected coding agent can request:
> Investigate the LPG-tax allegation using Pehchan. Return the finding, publisher sources, review status and relevant graph connections. Distinguish direct evidence from related context.
I verified tool discovery and calls using the official MCP client. A successful run inside a specific coding-agent application remains a separate integration check.

MCP exposes the investigation workflow through structured tools shared with the web application.
The shortened message exposed a real problem
The complete LPG allegation produced a successful dossier.
A shortened version exposed a failure worth documenting.
When I tested only the statement about state governments charging 55% tax, the system retrieved relevant LPG reviews but also included an unrelated two-wheeler toll-tax review as contradictory evidence.
That was a relevance error. The final human-review status did not make the unrelated citation acceptable.
This distinction matters: validating that a source exists in the graph is different from validating that it addresses the submitted proposition.
The application's tool restrictions and reference checks reduce some failure modes. They do not guarantee that a learned relevance assessment is correct.
That result gives me a concrete next evaluation target: short claims about taxes, prices and government policy that share vocabulary while asserting different things.
It also explains why responses remain reviewable drafts (every drafted reply is labeled as requiring human approval) and why human-review routing is part of the product.
Shortening the input exposed an incorrect relevance assessment, highlighting a limitation the next evaluation needs to cover.
What I measured, and what those numbers establish
I compared retrieval methods using 30 author-written held-out queries: 24 paraphrases and six translations (into Hindi, Spanish, German, French and Indonesian). None of the queries is stored in the graph, and the settings were fixed before the run.
The evaluation ran against the original 248-wording seed.
Method | Top-one hits | Top-five hits | Translation hits (top five) |
|---|---|---|---|
Word overlap | 25/30 | 25/30 | 3/6 |
FalkorDB vector index | 30/30 | 30/30 | 6/6 |
Vector index plus graph re-ranking | 30/30 | 30/30 | 6/6 |
Graph re-ranking added no retrieval gain on that set because embeddings already retrieved every accepted target.
The graph's demonstrated contributions were elsewhere: inspectable paths, context widening and recall through saved relationships.
These scores measure retrieval on a small test set. They do not measure factual accuracy, and they have not been rerun against the expanded collection ( recorded evaluation , evaluation script ).
The broader test suite checks ingestion fidelity, real graph queries, source preservation, persistence, authorization, tool-call handling and interface behavior. The 61 tests run against a live FalkorDB instance rather than a mock.

The original seed evaluation is reported with its scope, rather than presented as full-collection accuracy.
The build decisions that changed the project
The decision and flow registers became useful because several early assumptions needed revision.
Database persistence needed explicit verification.
An initial volume configuration did not match the image's actual data directory. The volume was mounted at
/data while the image keeps its data in /var/lib/falkordb/data , and the append-only flags were passed where the startup script never read them. The first container recreation cleared the graphs. I rebuilt them from saved input, corrected the mount and passed the flags through REDIS_ARGS , then checked retention across another recreation.Growing the graph exposed result limits.
After the larger import, whole-graph reads encountered a 10,000-row cap. The first embedding pass wrote 8,057 vectors and never visited 1,623 wordings, without raising an error. I changed embedding and coverage reads to ordered pages of 5,000 so that partial results would not appear complete.
Model latency needed separate measurement.
Fast local graph operations did not guarantee a fast investigation when hosted-model round trips dominated the wait. Testing smaller models helped reduce that cost while preserving the same application checks. On a Hindi 5G forward, GPT-OSS 120B took 48 s and GPT-OSS 20B took 14 s; the 20B model then gave the same findings as the 120B on the LPG, vaccine-microchip, 5G-coronavirus and nonsense test claims, in 12 to 18 s each, so it became the default.
Graph relationships needed their basis attached.
Source records, keyword annotations and model assessments carry different kinds of information. Recording their basis made both debugging and interpretation clearer.
The registers preserve those changes, including superseded choices. They explain how the current implementation emerged rather than presenting it as a design that worked perfectly on the first attempt.
What the walkthrough convinced me to build next
The LPG-tax claim is useful because it involves a believable calculation, historical evidence, multiple wordings and a meaningful distinction between direct review and surrounding context.
It also exposed a weakness.
Pehchan could assemble a source-backed dossier for the complete allegation, while a shorter version produced an incorrect relevance assessment. Both outcomes belong in the build story.
The next work is broader evaluation across the expanded graph, stronger relevance checks for policy and tax claims, better multilingual assessment, and more reviewed annotations.
My goal is an investigation a researcher can inspect: the wording submitted, the records retrieved, the connections followed, the uncertainty retained and the action taken.
Where each piece lives in the repo
Piece | File |
|---|---|
Record normalization and stable IDs | src/pehchan/records.py |
Ingestion into FalkorDB | src/pehchan/ingestion.py |
Fixed, parameterized Cypher | src/pehchan/queries.py |
Vector retrieval and bidirectional NLI (Claim Scout) | src/pehchan/semantic.py |
Narrative-frame and entity rules | src/pehchan/rules.py |
Specialists and evidence policy | src/pehchan/investigation.py |
Hosted-model tool loop | src/pehchan/inference.py |
MCP server | src/pehchan/mcp_server.py |
Graph schema | Docs/graph-schema.md |
Decision and flow registers | Docs/Decision.md · Docs/Flow.md |
Retrieval evaluation | scripts/evaluate_retrieval.py · Docs/retrieval-evaluation.json |
Pehchan AI: Beyond the claim. Into the connections.
Built with assistance from Codex and Claude Code. Publisher evidence remains attributed to its original sources. Rule annotations and model assessments are identified separately.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article