VEYRA
The AI That Connects the Unseen
A fake brand advertisement. One OTP. ₹7 lakh gone.
An Instagram message from an unknown sender. ₹36,000 lost.
A friend’s account got hacked. The attacker used that trusted identity to manipulate people into sending money.
A prepaid clothing order. The account disappeared. ₹10,000 gone.
A known influencer I knew reportedly lost ₹17 lakh to a digital arrest scam.
Different scams. Different victims. The same disturbing reality: evidence scattered, connections hidden.
I kept asking myself: What if we could connect the dots before someone else became the next victim?
That question led me to build VEYRA, a cyber-forensics intelligence platform powered by FalkorDB, designed to connect digital evidence, uncover hidden relationships, and reveal the networks behind online scams.
Because behind every scam, there may be a network. VEYRA helps uncover it.
Let Me Introduce VEYRA
VEYRA is a cyber-forensics intelligence platform built to uncover the hidden networks behind online scams.
Powered by FalkorDB, VEYRA connects suspicious accounts, URLs, domains, impersonated brands, and reported activity in a connected evidence graph. Instead of investigating each clue in isolation, it follows relationships across multiple hops to uncover connections and patterns that might otherwise go unnoticed.
But VEYRA goes beyond connecting the dots. Its AI agent helps investigators explore findings, ask follow-up questions, and revisit previous investigations using available case history and persistent conversation memory.
The mission is simple: Uncover the network. Expose the threat.
01. The Landing Page: A Network of Evidence
The moment you enter VEYRA, you’re greeted by a living network of connected nodes, bringing digital evidence to life.
Powered by FalkorDB, the landing page visualizes the relationships stored in VEYRA’s graph. Accounts, URLs, domains, brands, and reports are represented as connected entities, revealing how seemingly unrelated pieces of information may share a common link.
Instead of presenting evidence as isolated records, VEYRA introduces its core idea visually: every connection can lead to another clue, and every clue can help build a bigger picture.
The graph is more than a background animation. It represents the connected-evidence approach at the heart of the platform, giving users a first glimpse of how VEYRA explores relationships hidden within digital data.
One graph. Connected evidence. Hidden relationships waiting to be uncovered.
02. The DM Simulator: Trust the Evidence, Not the Message
The DM Simulator populates sample direct messages using scenarios connected to VEYRA’s FalkorDB graph, bringing synthetic scam scenarios to life for investigation.
Users can explore suspicious brand promotions, malicious-looking links, and potential impersonation attempts. When a message is submitted, VEYRA investigates its indicators and traces connected accounts, URLs, domains, and reports through the graph.
The findings appear in the investigation workspace, helping users understand the connections behind each message.
One message can reveal a bigger network. VEYRA helps you investigate before you trust.
03. The Investigation Workspace: Connect the Dots
VEYRA brings together graph intelligence, multi-hop traversal, AI-powered investigation, and persistent context to uncover connections hidden across digital evidence.
1. From a Suspicious Message to an Investigation
The process begins when a user submits a suspicious message through VEYRA’s DM Simulator. The FastAPI backend receives the request, creates an investigation case, and passes it to the investigation pipeline.
The pipeline examines the available indicators and queries FalkorDB to retrieve relevant entities and relationships. Instead of treating a suspicious message as an isolated event, VEYRA uses the connected evidence graph to explore what lies behind it.
2. FalkorDB: The Connected Evidence Graph
FalkorDB is the graph database at the heart of VEYRA. It stores entities as nodes and their connections as relationships.
These entities can include accounts, messages, URLs, domains, brands, reports, payment identifiers, and supporting evidence.
For example, a suspicious account may be connected to a URL, which points to a domain shared by several other accounts. Those accounts may have additional relationships with reports or other evidence.
By storing these connections as a graph, FalkorDB allows VEYRA to query relationships instead of examining every indicator independently.
3. Multi-Hop Traversal: Following the Hidden Connections
This is where VEYRA becomes more than a simple message detector.
Multi-hop traversal follows relationships from one entity to another, expanding the investigation step by step.
Example investigation path:
Suspicious Account → Shared URL → Domain → Connected Accounts → Reports and Evidence
The first hop identifies a URL connected to the suspicious account. The next follows that URL to its domain. Further hops explore other accounts associated with the domain and check for related reports or supporting evidence.
VEYRA’s traversal logic queries FalkorDB, follows the available relationships, and collects relevant connected entities and paths for analysis. The findings can then be displayed in the investigation workspace as an interactive evidence graph.
These connections are investigative leads, not automatic proof of fraud. VEYRA helps expose relationships that investigators can examine in context.
4. MCP and the AI Agent: Turning Graph Data into Answers
VEYRA’s AI agent helps users explore investigation results and ask follow-up questions in natural language.
The Model Context Protocol (MCP) provides an interface through which the agent can access structured investigation tools. These tools execute the relevant operations, retrieve graph information when required, and return structured results to the agent.
The agent can use those results alongside available case details and relevant conversation context to explain connections, answer questions, and guide further investigation. The Groq language model supports the AI reasoning and response-generation layer.
The responsibilities are distinct: FalkorDB stores connected evidence, traversal logic explores relationships, MCP exposes tools to the agent, and the AI agent helps interpret the retrieved results. Not every operation needs to pass through MCP; the main investigation pipeline can query FalkorDB directly.
5. Persistent Memory and Investigation History
An investigation should not lose its context when a conversation ends.
VEYRA separates three important responsibilities:
- Graph storage: Preserves relationships between accounts, URLs, domains, reports, and other evidence.
- Case history: Preserves saved investigation records so previous cases can be revisited.
- Persistent conversation memory: Helps retrieve relevant context from earlier interactions when answering future questions.
When a user reopens a case or asks a follow-up question, VEYRA can use the available saved case details, graph evidence, and relevant conversation context to continue the investigation without treating every interaction as a completely new starting point.
04. Cases & History: An Investigation That Remembers
An investigation shouldn’t end when the first report is generated. The ability to revisit earlier findings, understand how an investigation progressed, and ask new questions is just as important as discovering the initial connections.
That’s why VEYRA includes a dedicated Cases & History workspace.
1. Investigation Cases: Every Investigation Has a Record
The Cases page brings saved investigations together in one place. Users can browse previous cases, search for a particular investigation, review its status, and reopen a case to explore its details.
Get Bavyasakthivel’s stories in your inbox
Join Medium for free to get updates from this writer.
Instead of starting from scratch every time, investigators can return to earlier work and continue examining the available evidence.
2. Case Details: Revisit the Investigation
Opening a case takes the user into its investigation details. Depending on the information saved for that case, the workspace can show the investigation identifier, status, primary entity, findings, and other associated information.
This provides a central place to understand what was investigated and what the system discovered.
3. Execution Timeline: Follow the Investigation Step by Step
The execution timeline makes the investigation process easier to follow. It presents recorded investigation events and steps in sequence, helping users understand how the analysis progressed.
For example, an investigation may begin with an initial suspicious indicator, expand through connected graph relationships, and produce findings for further review.
The timeline provides visibility into the recorded process rather than presenting only a final conclusion.
4. Graph View: Explore the Connected Evidence
Powered by FalkorDB, VEYRA’s graph investigation capabilities help users explore relationships between entities discovered during an investigation. Accounts, URLs, domains, and other available evidence can be represented as connected nodes and edges.
This is especially useful for multi-hop investigations, where a connection discovered in one step can lead to another relevant entity. Instead of viewing each clue independently, users can explore the wider network and investigate how the pieces relate to one another.
5. AI Agent Chat: Continue Asking Questions
An investigation often leads to more questions. VEYRA’s AI agent chat allows users to ask follow-up questions and explore the available findings in natural language.
The agent can use retrieved graph information, saved case details, and relevant conversation context to explain relationships or help the user examine another angle.
For example, a user might ask which accounts share a domain with the suspicious account or what supporting evidence is available for a particular connection. The answer depends on the graph data and context the system can retrieve.
6. Persistent Memory: Carry the Context Forward
VEYRA separates persistent conversation memory from saved investigation history.
Case history preserves the investigation record, while conversation memory helps the agent retrieve relevant context from earlier interactions. FalkorDB maintains the connected evidence graph, preserving the relationships that help investigators explore connections across entities.
Together, these components can help users revisit previous investigations and continue asking questions without treating every interaction as an entirely new starting point. The continuity depends on the case data, conversation context, and graph evidence that have actually been saved and retrieved.
From a single suspicious message to an investigation that can be revisited, explored, and continued, VEYRA brings connected evidence and investigative context together, powered by FalkorDB.
05. FalkorDB: Where Connections Come to Life
One of my favourite parts of building VEYRA is seeing scattered digital evidence transform into a living, connected graph powered by FalkorDB.
I populated the graph with structured investigation data representing accounts, messages, URLs, domains, brands, reports, and supporting evidence. Each entity becomes a node, and its relationships become edges.
The real magic happens when we query the graph.
Instead of inspecting one entity at a time, VEYRA follows connected relationships across multiple hops:
Suspicious Account → URL → Domain → Connected Accounts → Reports
With graph queries and multi-hop traversal, VEYRA can move from an initial clue to related entities, uncover shared connections, and retrieve relevant evidence. The graph UI makes these relationships easy to visualize and explore, revealing how seemingly unrelated clues may connect.
As graph data changes, new queries can retrieve the updated relationships without rebuilding the entire graph. This makes investigation faster, more interactive, and easier to follow.
But what truly makes VEYRA unique is how it brings these connections to life. Rather than simply displaying a massive graph, it can highlight the particular connected nodes and relationships relevant to the investigation, making the evidence path easier to follow and explore.
Nodes reveal the entities. Edges reveal the relationships. And multi-hop traversal reveals the bigger picture.
That’s how VEYRA transforms connected graph data into a more visual, interactive, and explainable investigation experience.
Nodes reveal the entities. Edges reveal the relationships. Multi-hop traversal reveals the bigger picture.
With FalkorDB at its core, VEYRA turns connected data into actionable investigative insights.
06. Beyond the Graph: Questions About VEYRA
1. How does VEYRA detect suspicious messages?
It analyzes submitted messages and investigates available indicators using VEYRA’s investigation pipeline and connected graph evidence.
2. How does multi-hop traversal work?
VEYRA follows relationships across FalkorDB, connecting accounts, URLs, domains, and related reports to uncover wider networks.
3. How are report nodes created?
Reports represented in the dataset or reporting workflow can be stored as graph nodes and linked to relevant entities and evidence.
4. How is data stored in FalkorDB?
Entities are stored as nodes, and their relationships as edges. Graph queries retrieve connected evidence for investigation.
5. Does VEYRA remember previous investigations?
Saved case history and persistent conversation memory help retrieve previous findings and relevant context across sessions.
6. Can VEYRA detect every scam?
No. VEYRA helps uncover suspicious patterns and connections, but findings require context and appropriate verification.
7. What’s next for VEYRA?
I’m exploring richer evidence provenance, explainable investigation scores, automated evidence correlation, real-time threat intelligence integration, and smarter investigation recommendations to help uncover emerging scam networks faster.
Have more questions or ideas? I’d love to hear from you! Connect with me on LinkedIn and let’s talk about VEYRA, graph intelligence, and building safer digital spaces.
How I Built VEYRA: The Night I Almost Gave Up
I had the backend running, the frontend taking shape, and FalkorDB ready to connect the dots. In my head, everything was falling into place. In reality? Everything had other plans. 💀
The challenge wasn’t just getting everything running. Duplicate data kept appearing in the graph, and the wiring between the frontend, backend, and FalkorDB wasn’t behaving as expected. API responses weren’t flowing correctly, graph queries needed verification, and I had to trace the data through every layer to find where things were breaking. I fixed the connections, checked the generated data, and repeatedly validated the nodes and edges to make sure the graph represented meaningful relationships instead of duplicated or disconnected information.
One broken integration led to another. Fix one error, restart the application, and somehow discover two more.
⏳ Four hours left.
I genuinely thought about giving up. Then, with barely two hours remaining, I made a deal with myself: One last attempt. If it works, we continue. If not, at least I tried.
I went back to the basics. Check the backend. Trace the API calls. Fix the connections. Query FalkorDB. Verify the nodes and edges. Repeat.
And then, the breakthrough. 🔥 The frontend finally started receiving the backend’s responses. FalkorDB returned connected graph data, and the relationships began appearing as they were supposed to. The pieces that had been fighting each other were finally working together.
Watching an account connect to a URL, a domain, and other related entities made every frustrating debugging session feel worth it.
I didn’t build VEYRA in one perfect run. I built it by refusing to let one broken connection become the end of the story.
Sometimes, the most important line of code is the decision to try one more time.
And just like that, VEYRA came to life. 🚀
What started as a messy collection of errors became a working platform where the frontend, backend, and FalkorDB finally connected. The graph came alive, multi-hop relationships became explorable, and the investigation workflow started coming together.
Key takeaway: This journey taught me that building a real-world system is about more than writing code. It’s about debugging patiently, understanding how components communicate, validating data, and turning failures into lessons that make you a better developer.
It wasn’t the smoothest journey, but it was one I’ll never forget. Every failed connection taught me something, and every fix brought VEYRA one step closer to reality.
Curious to see VEYRA in action?
🎥 Watch the Demo: https://youtu.be/yANb3tzrCDY?si=6bDflRpc1Wy5qjZ3
💻 Explore the Code on GitHub: https://github.com/BAVYASAKTHIVEL-21/Veyra
From debugging chaos to connecting the dots, this is VEYRA. 🔍
![🪸KORA-SRE [Knowledge Oriented Reliability Agent]🪸](https://webproxy.poorya-velaei-d67.workers.dev/https://miro.medium.com/v2/resize:fit:1358/format:webp/1*k90y8tDofnh4OaemWw6LlQ.png)
