Some questions are about the relationship between two specific things.
How often did this patient visit this clinic, and when? When did this agent use this tool, and how many times?
In ApertureDB, FindConnection restricts relationships by source, destination, or both. It then supports constraints, sorting, offset and limit, counts and aggregates, and grouping. The example in the image is the patient and clinic question. Illustrative data.
Docs:
docs.aperturedata.io/query_l…
The Cognitive Layer, Episode 4: Dr. Denise Gosnell, ex-DataStax CDO and co-author of Tech Confidential, on shared meaning as the main blocker for enterprise AI and on tying an AI architecture to a revenue goal. Also covered: SQL versus natural language, agent memory as a markdown file, and neuromorphic computing, where a test problem ran on 7% of the power.
YouTube: youtu.be/Qrk4q2kVYyk
Blog: aperturedata.io/resources/th…
Dr. Denise Gosnell (ex-DataStax CDO, co-author of Tech Confidential) on how to tell an AI science experiment from a project that earns revenue: find the revenue goal, then "work backwards from that". The Cognitive Layer, Episode 4.
When an agent learns that something it remembered is wrong, the easy fix is to replace the old value.
That can make the next answer better. It also erases how the system got there.
A useful memory needs to keep the source, scope and reason for a fact, and connect a superseded rule to the one that replaced it. Then the agent can use the current version without making the earlier one disappear from the history.
There is a separate question: who decides which source is right? A memory layer can preserve conflicting claims and make the conflict visible. The agent or the business still has to judge them.
Correction should change what applies now, without making the history unqueryable.
A product’s colors can be an array. A contract’s amendments can’t.
Whether an attribute should be a value or its own node depends on what else needs to qualify it, and how many relationships it has.
For a simple property like a product’s available colors, an array is usually enough. But an amendment is not just another value on a contract. It changes a particular clause, may itself be changed later, and needs to point to the clause it replaced.
If you flatten that history into fields, you lose the path that tells you what is in force now. Model the amendment as a node with relationships to the clauses it changes, and the graph can preserve that context.
The question is not “is this data a graph?” It is whether the relationships carry meaning you will need to query.
Saving a conversation is the easy part of agent memory. Deciding whether a saved thing is still true is the hard part.
Four questions every memory write should answer, and most do not:
- Who provided it. An agent that cannot tell a customer’s statement from a policy document will treat both as fact.
- When it was true. A preference from eighteen months ago is not a preference. Time has to be on the record, not inferred at read time.
- Whether it still applies. Something superseded needs an edge to what replaced it. Without that, retrieval returns the old version confidently, because it reads almost the same.
- Who is allowed to see it. Memory scoped to a user is not memory scoped to a session, and neither is memory scoped to a tenant.
We built Aperture Nexus so each commit, context and session lands as a graph entity with provenance attached at write time, rather than reconstructed later.
That does not decide retention for you. It makes the decisions you do make auditable.
It was also good we closed on the vision: where we want to take the product, and where I hope AI takes the world. I am on the Star Trek side, not the Terminator side.
Part of that vision is Aperture Nexus, our open-source memory layer built on ApertureDB. We are collaborating with the people using it and improving it every day, and we would love for you to try it and help shape it:
github.com/aperture-data/ape…
@DmitryKan has shared so much through the Vector Podcast with vector database founders.
In this episode, we get into why AI makes it important to have one database where a single query can combine relationships, text and document search, and images or video.
The knowledge graph sits in the same database as vector search and storage for text, documents, images, video, audio, and blobs.
I have lived this from my Intel Labs research days to building @ApertureData, and we talk about what motivated both.
What you get from the episode:
- Tech depth: the research behind ApertureDB and the JSON query language
- Founder lessons: how we describe the product, from "visual data management system" to "data and memory layer for AI", and why I use the words people already know
Episode:
youtube.com/watch?v=U6Wq_WXe…
Thank you for inviting me, Dmitry. I am very happy to be included.
New episode on the graph database for multimodal search ApertureDB with its CEO and co-founder @vishakha041 - recorded in sunny Cupertino, in Memorial Park. Really enjoyed this discussion on my way to SF airport from @OpenSearchProj conference. youtube.com/watch?v=U6Wq_WXe…
An agent picking dinner needs to know what fits under 600 calories, and how it splits by cuisine and diet, before it reads any recipe.
In ApertureDB, group returns per-value counts for the properties you list, with an average per group, without fetching the records:
"constraints": ["$calories", "<=", 600],
"results": {"group": ["cuisine", "diet"], "average": "calories"}
The agent picks the next filter from the counts.
Docs:
docs.aperturedata.io/query_l…
Vector search plus a simple filter, like ownership, is fast and often enough for RAG.
When relevance depends on relationships, walk the knowledge graph first: customer, model, part, manual. Then rank only those manuals by similarity to the photo of the failed part.
Embeddings and the graph live in one database, so moving from simple RAG to graph RAG is a change to the query, not the database.
Docs:
docs.aperturedata.io/query_l…
ApertureDB supports ACORN for filtered vector search on the HNSW engine. It finds neighbors that satisfy property, label, and relationship constraints. Approximate, so results can differ from the default exact search.
Off by default. Set filtered_knn to true, with k_neighbors.
Docs:
docs.aperturedata.io/query_l…
Aperture Nexus does not decide what your agent remembers. That was deliberate, and we're now asking whether it's what people building agents actually want.
Right now the API does the persistence work. It stores a full video, adds embeddings, and writes the record. It does not decide what to summarise, what to retain, or when to prune. The agent calling it makes those decisions. We don't add our own reasoning or memory-management logic on top.
The layer still gives you structure. Every commit, context and session becomes a knowledge graph entity the moment it is written, with provenance on each one. Memory is scoped to users and sessions. It is model-agnostic, so you bring your own embedding model keys or provider.
The argument for leaving retention to the agent is that the agent knows its task. A coding agent and a support agent shouldn't forget the same things. The argument for ready-made behaviour is that otherwise each team ends up writing its own summarise-and-prune logic.
We're considering design-partner work to settle this. If you're building agentic applications: which memory decisions would you hand to the memory layer, and which would you never let it make for you?
ApertureDB array properties can be indexed. An array index can speed up membership checks and selected-element lookups.
["red", "in", "$colors"]
[{"at": ["$colors", 0]}, "==", "red"]
Docs:
docs.aperturedata.io/query_l…
In a contract, the clause that got overridden and the clause that replaced it mean almost the same thing. To an embedding model, they're neighbors.
That was the hard part when we built a legal agent. The question was never "which passage looks like this one." It was "which clause is in force right now, and what did it replace?" Similarity search can't answer that, because the superseded version and the current one are close to identical in meaning. The amendment history and the relationships between clauses are what tell them apart.
What got us the right answers:
- Curating the graph structure so each amendment points to what it overrides
- GraphRAG over that graph to follow the chain to the version that's current
- The multimodal-native API in ApertureDB (@ApertureData) to pull the exact paragraphs from the source documents
The graph relationships, the metadata, the embeddings and the documents themselves all sit in one database. The traversal and the retrieval happen in the same place, so we didn't need a pipeline stitching three systems together to answer one question.
The graph in between stores context beyond the basic entities, like which amendment changed which clause and what's still standing after it.
People type "Scarlet Johanson." A typo-tolerant full-text match on the name finds Scarlett Johansson as the entity, and the knowledge graph traversal can start there: films, co-stars, their other work.
Each query word gets its own max_edits. The search starts with exact matches, allows one more edit at a time up to the ceiling you set, and stops at the first step that returns results. Results are ranked with BM25.
The constraint, on a property with a fulltext index:
[{"fulltext": ["$name", "harbr lihgts", "all", 4]}, ">", 0]
Docs:
docs.aperturedata.io/query_l…
We have a name for the data layer most AI teams end up with: the Frankenstack.
A search engine for text, a vector database for similarity, a knowledge graph for relationships. Pipelines stitch them together so one question can touch all three. The data gets copied between systems and has to stay in sync. The filtering logic ends up in application code, because no single system sees the whole picture.
We built ApertureDB (@ApertureData) so those three live in one engine. When we measured it:
- Vector search runs 2 to 10x faster than popular vector databases
- Property-graph queries run about 30x faster than well-known alternatives
- Teams that consolidate these along with their unstructured data onto ApertureDB see up to 35x overall
The 35x is the one I care about most, because it's what happens when the pipelines between systems go away.
(I won't name the alternatives. You probably have a few of them running right now.)