Knowledge Graph Consulting: The Context Layer for Your AI Agents
Your agents answer from whatever the retriever found, and too often it is last quarter's truth. I build the context layer they answer and act from: a temporal knowledge graph that knows which fact is current, where it came from and who approved it, running on your own tenant.
- 2Time axes on every factWhen it held, and when it was recorded
- 6Systems in one layerChat, tickets, wiki, CRM, mailbox, meetings
- 0Writes without a person's approvalOn every door, MCP included
- 1Your own tenantCompute, storage, graph and models
What a context layer is
A context layer decides what an AI agent knows at the moment it answers or acts: which fact is current, where it came from, and who may see it. Built on a temporal knowledge graph, it keeps every fact with the time it held and the time it was recorded, so a changed decision replaces the old one instead of competing with it in a similarity search.
A retriever over documents returns passages that look like the question. It cannot tell which of two contradicting passages is still true, and it cannot say who signed either of them. That is where agents go wrong in front of customers, and it is the part I build.
Why a temporal knowledge graph
- Current, not only similar. Facts are edges between entities, each with a validity window. When a new fact contradicts an old one, the old edge is closed, not deleted, so you can ask what is true now and what was true in March.
- Sourced. Every fact points back to the episode it came from: the ticket comment, the meeting note, the CRM field. An answer carries the passage, and a reviewer can open it.
- Incremental. New data lands as it arrives, without re-indexing the whole corpus. That matters when the source is a chat channel and not a document archive.
- Readable by machines and people. Hybrid search over embeddings, keywords and graph distance feeds the agent, and the same graph answers a person in chat.
I build on Graphiti, the open-source framework for temporal knowledge graphs, and I maintain Graphiti Local, a read-first interface to it: six read-only MCP tools, a kg command line, and a write path that waits for a person. The mechanics are in the guide on temporal knowledge graphs, the comparison with Mem0 in Graphiti vs Mem0, and what running it takes in Graphiti in production.
What you get
| Part | What it does |
|---|---|
| Ingestion | Reads the systems you already run, such as Teams, Jira, Confluence, your CRM, mailboxes and meeting notes, with their own ids, resumable and without duplicates |
| The graph | Graphiti on FalkorDB or Neo4j inside your tenant, one graph or one group per business domain |
| Read doors | Chat for people, MCP for Claude, Codex and other assistants, and a command line for scripts and scheduled jobs |
| Write path | Agents propose, a person approves on a card in chat, and the graph records who approved and from which source |
| Permissions | Every read runs with the signed-in person’s own permissions; a hit they may not open is dropped |
| Operation | Snapshots before migrations, an ingest ledger, gap telemetry per source, and audit events per door |
Where it runs
Compute, storage and the graph run in your own cloud tenant. On Microsoft Azure the language models come from Azure AI Foundry in that tenant: OpenAI’s GPT-5.6, with Luna for high-volume lookups and Terra for reasoning and tool use, deployed as Data Zone Standard in the EU, so prompts and responses are processed inside the EU data zone. Where data must not leave your network, extraction and embeddings run on a self-hosted model instead.
Who this is for
Companies whose assistant already reads chat, tickets, wiki and CRM, and now has to answer from the current state and act only with a person’s approval. You have decided the assistant will act, and the work starts there. It is not for teams still deciding whether to use AI at all.
Graphiti Local is an independent community project built on Graphiti. It is not affiliated with or endorsed by Zep.
The way in
Four steps, each accepted on its own. The first is free, the rest are billed by the hour, and none of them commits you to the next.
- 1Architecture call, 30 minutesYou bring the systems your agents read and the questions they get wrong. We find the first source, the first door and the facts that go stale fastest.
- 2Write-path review, a set number of hoursThe AI Pilot to Production Audit: which facts your agents answer from today, which of them are stale or unsourced, who approves what they write, and the changes in priority order. A document for security and procurement.
- 3Phased build on your tenantFirst source into the temporal knowledge graph, first door (chat or MCP), first approval card. Phases accepted one by one, billed by the hour.
- 4OperateIngest ledger and gap telemetry per source, snapshots before every migration, and the approval classes that may move to review-after-the-fact once the trail shows they are clean.
Go deeper
Frequently asked
What does a knowledge graph consultant do for AI agents?
Decides what the agent is allowed to know and how that knowledge stays current. In practice: which sources feed the graph, which entity and relation types it keeps, how a new fact closes an old one, who may read what, and which writes need a person. Then I build it on your tenant and hand over the operation.
Is a knowledge graph better than RAG?
For facts that change, yes. Vector RAG returns passages similar to the question and cannot tell which of two contradicting passages is current. A temporal knowledge graph stores each fact with its validity window and its source, so the agent gets the fact that holds today. For static reference text, plain retrieval stays the simpler choice, and the two combine well.
Do you work for Zep?
No. Graphiti is Zep's open-source framework under the Apache-2.0 license. I build on it and maintain Graphiti Local, an independent community project that is not affiliated with or endorsed by Zep. Zep Cloud is the managed service from the vendor; this work is for teams that run the graph in their own tenant.
Which graph database do you use?
FalkorDB or Neo4j, inside your tenant. FalkorDB is fast and gives every tenant its own named graph; its license is the SSPL, which some procurement policies exclude. Neo4j is Graphiti's default backend; clustering and role-based access need its Enterprise edition. For one person or a laptop, an embedded LadybugDB file through Graphiti Local is enough.
Where does the data go, and where does inference run?
Compute, storage and the graph stay in your cloud tenant. On Azure the models are OpenAI's GPT-5.6 in Azure AI Foundry, deployed as Data Zone Standard in the EU, so prompts and responses are processed inside the EU data zone. Self-hosted models are the option when nothing may leave your network. The review document states this per model, because your security review will ask.
What does it cost?
The architecture call is free. The write-path review takes a set number of hours, named in the call, and is the first deliverable. The build is billed by the hour, phase by phase, with an hour estimate before each phase and phases you accept one by one.