AI Engineer World's Fair 2025
Graph Intelligence: Enhance Reasoning and Retrieval Using Graph Analytics
Loading slides…
Read the talk
Graph Intelligence: Enhance Reasoning and Retrieval Using Graph Analytics
A graph can connect retrieved chunks to their sources, conversations and neighbors, giving engineers practical ways to diagnose redundancy, diversify context and trace what their applications amplify.
From a talk by Andreas Kollegger
Before you start: Familiarity with retrieval-augmented generation, text embeddings and basic Python will help; graph concepts and Cypher patterns are introduced as they are used.
What information is your retriever missing?
Are you retrieving the right data, chunking it appropriately and preserving the relationships that make an answer useful? Those questions open the workshop’s technical discussion. The audience adds two immediate difficulties—establishing relationships and managing volume—then raises temporal relationships. Graph analytics offers ways to investigate these problems together. As Cossette explained before these audience questions, the accompanying Jupyter notebooks support that investigation, but the underlying responsibility extends beyond the pipeline: AI engineers must care about both the pipes and the quality of the water flowing through them.
A vector store is a useful starting point. Alison Cossette compares its chunks to index cards handed to someone on their first day at work: each card contains a relevant fact, but the newcomer still needs to know how those facts fit together. Semantic similarity can find a promising card without explaining what it connects to. A knowledge graph brings structured and unstructured information together to supply those connections. Some relationships come from explicit material, such as a table extracted from a document; others require an LLM to identify entities and infer relationships from prose. The workshop starts with an already-built database combining several sources.
Consider two people and a car. One person owns the car; another drives it. The people also know each other. These are nodes and relationships, with properties supplying the details: a person’s attributes, the car’s brand and model, or the date when someone began driving it. The analogy to relational tables, foreign keys and columns is approximate, but useful for orientation. Properties can belong to relationships as well as nodes.
The car also has a description and a description embedding. To answer a question about people who own cars described a certain way, retrieval first uses vector similarity to find matching car nodes. It then traverses ownership relationships to reach the people. Semantic search supplies the entry point; graph traversal supplies connected context. Because the relationships already exist, the retriever does not need a new table or view for each such question.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Put application activity in the graph
Start with a document connected to its chunks, then connect the application to those chunks. Prompts, assistant responses and retrieved context record what the system actually does. This application graph, also described as a memory graph, lets you investigate which documents get used and which may influence outcomes. Chunks can also connect to products, people and other domain entities drawn from structured sources or extracted from documents. The workshop concentrates on the smaller slice containing prompts, responses and their context documents.
These are neighborhoods within one system, not separate databases. In the explanatory diagram, yellow nodes identify application data and blue nodes identify information from unstructured sources. The colors distinguish origins and roles; the relationships make it possible to query across them. Starting with one connected system does not require designing an entire organization’s ontology before doing useful work. Begin small and keep the application’s latency requirements in view.
Schema complexity and data volume are different dimensions of graph size. Many labels and relationship types can make a graph difficult to work with even before its node count becomes large. The practical sequence is:
- Start with generic labels and relationship types.
- Load a representative subset of the data.
- Evaluate whether it supports the questions you need to answer.
- Specialize the schema where the results or volume justify finer distinctions.
- Bring in the remaining data after refining that model.
Here, starting small means iterating on the ontology as well as limiting initial ingestion.
The same evaluation discipline applies to the audience’s comparison with RAPTOR, which organizes content into a hierarchy with summaries at higher levels. A tree of summaries, summaries over graph communities and an entity-and-relationship representation expose different routes through the material. The questions users ask should determine which representation earns its place. The workshop offers no performance winner between RAPTOR and knowledge graphs.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Explore more relationships, then load the workshop environment
The workshop distributes its repository and an OpenAI key through the conference workspace. For readers following the recorded setup, the clarified Slack channel is workshop-neo4j, not workshop-neo4j2025; Graph Analytics Workshop is the repository name discussed during that exchange.
Why add relationships to an existing corpus? A chunk can answer questions about its own contents. A pair of chunks can also support questions about their similarities, differences or connections. Communities add another level: questions about connected groups. The co-presenter illustrates this with a deliberately simple counting model—one question per chunk, then a Cartesian product of pairs, then possible subsets:
His ten-chunk illustration has 100 ordered pairs. These are candidate combinations, not measured answerability gains: a useful question does not automatically exist for every pair, and the connected communities do not realize every possible subset. The useful intuition is that relationships expose questions unavailable when chunks are considered only in isolation.
The recorded exercise uses a hosted AuraDB Professional trial. The repository refresh adds the slides and setup links, and participants are told to ignore its Docker instructions for this session. Aura Free is presented as a smaller option for later experimentation, while the Professional trial supplies the workshop environment. Cossette initially estimates a longer trial, then corrects herself to the seven days displayed in the interface; those are historical setup details, not a current offer. No cloud-provider preference is required. Participants pass through onboarding, retain the default four-gigabyte instance and can enable graph analytics and vector optimization before starting it.
The console brings together instances, graph analytics and a query IDE. Its first Cypher pattern is deliberately small:
cypher
MATCH (n)
RETURN n
LIMIT 10;
Parentheses identify a node pattern; n names the matched node for the return clause. The notebooks contain the workshop queries. During account troubleshooting, Cossette also describes creating a fresh workshop account with a +workshop email alias when an existing account does not show the trial option. That is part of the recorded setup exchange, rather than a prerequisite for understanding the graph.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Follow Agent Neo’s conversations into their context
The dataset comes from Agent Neo, an application built around graph data science knowledge. Query results can appear as a graph, a table or raw values. Its application model records a session, conversations, user messages and assistant responses, with responses connected to the context chunks retrieved through cosine similarity. The grounding material comes from documentation, developer blogs and support content. Early ingestion used LangChain’s recursive splitter with a stated chunk size of 512.
The example conversations begin with requests to build graphs and questions about what GDS means. A follow-up asks how to learn more about GDS. Repeated opening questions draw on shared context documents; later turns move toward other information areas. That movement becomes visible because the conversation and its evidence are represented together. You can distinguish chunks used in both answers from chunks exclusive to one response, then investigate which parts of the corpus people repeatedly reach.
In the conversation visualization, pink nodes represent chunks, orange nodes represent user prompts and tan nodes represent application responses. This turns an otherwise isolated retrieval result into a usage trail: a prompt leads to an answer, and that answer identifies the material supplied as context.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Store searchable representations and scope retrieval
Agent Neo stores both chunk text and its embedding as node properties, with a vector index over the embeddings. That removes the need for a separate vector database in this design. In response to a storage question, the co-presenter distinguishes ordinary kilobyte-scale chunks from megabyte-scale payloads, which warrant more concern. A subsequent question about growing legal-document collections receives only informal scale guidance: the discussion mentions tens of millions as seeming manageable and hundreds of millions as requiring further scaling work, without specifying the counted unit, workload, hardware or latency target. It does not establish a deployment capacity.
A vector query searches the contents of its chosen index. Multiple indexes can therefore separate use cases or available datasets; the workshop gives a governance example involving broadly available and restricted information. Large media use a different storage split: keep images in external storage such as S3, and put their URLs and embeddings on graph nodes. Relationships can then preserve the association between a document’s text and its images without placing the image binaries in the database.
Retrieval also depends on the graph pattern followed after finding an entry point. Cossette’s GPS analogy is to start somewhere and then follow a specified route. She points to the Python GraphRAG package and the GraphRAG pattern catalog while discussing pre-filtering, post-filtering and index scoping. Source structure can help: SEC filings contain predictable sections, so chunks can retain their place in a document hierarchy. Multiple labels provide another useful distinction. A node labeled both Message and Assistant can participate in a query over all messages or a narrower query over assistant responses. This is a retrieval-design explanation; the audience’s question about the vector index’s internal multilayer architecture is not resolved in detail.
Versioned documentation supplies a concrete scoping example. Separate indexes for versions such as 1.9 and 2.6 let a chatbot route a customer’s question to documentation matching the installed version. Cossette presents this as her practical preference. The subsequent clarification distinguishes that choice from filtering retrieved nodes: a vector index produces candidates, then property predicates can remove candidates that do not meet the application’s requirements.
The filtering exchange describes the workshop-era API. The current vector-index documentation records additional indexed filtering properties and SEARCH WHERE introduced in Neo4j 2026.01. When reproducing the exercise, keep its index-scoping and post-filtering explanation distinct from those later capabilities.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Restore the snapshot and inspect the graph
The workshop restores an Agent Neo snapshot instead of rebuilding the graph from CSV files:
- Download the Neo4j dump linked under the README’s Connect to Neo4j AuraDB section.
- Open the instance’s three-dot menu and select Backup and Restore.
- Browse for the dump or drag it into the restore interface.
- Open Query and check that database labels, relationships and indexes appear.
Some algorithm results are already present in this snapshot. The later walkthrough therefore combines precomputed results with live operations.
Participants who lack the dump link are asked to refresh the repository. Slow uploads and repeated loading screens are attributed to workshop networking. Cossette also keeps a local copy in Neo4j Desktop, which supports following the work without a cloud connection and provides an alternative for local or on-premises use.
The first of the three notebooks, Get to know your graph, installs the requirements and establishes a database connection. Downloaded credentials—including the connection URI—belong in .env. The OpenAI key is used relatively little in these analytics exercises. The notebook imports environment variables, uses the Neo4j Python driver and wraps queries in a small helper. A compact version of that connection pattern is:
python
import os
from dotenv import load_dotenv
from neo4j import GraphDatabase
load_dotenv()
with GraphDatabase.driver(
os.environ["NEO4J_URI"],
auth=(
os.environ["NEO4J_USERNAME"],
os.environ["NEO4J_PASSWORD"],
),
) as driver:
def run_query(query, parameters=None):
with driver.session() as session:
result = session.run(query, parameters or {})
return [record.data() for record in result]
print(run_query("MATCH (n) RETURN count(n) AS node_count"))
The recorded troubleshooting checks whether .env loaded and whether the URI scheme matches the downloaded credentials.
After connecting, the notebook uses APOC—introduced as Awesome Procedures on Cypher—to inspect the restored database. Cossette reports approximately 17,000 nodes, 774,000 relationships, seven labels and 27 relationship types in the workshop snapshot. These counts serve as a load check. Directly copying values into a notebook cell is suggested during the session as a diagnostic shortcut. The first notebook finishes with summary statistics and document previews, establishing what is present before the next notebook begins changing how the corpus is organized.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Connect, cluster, curate
The second notebook introduces a three-stage corpus-management process:
- Connect: run nearest-neighbor similarity over document embeddings. The workshop uses K = 25 to build connections among similar chunks.
- Cluster: run community detection over those connections, grouping related chunks for collective inspection.
- Curate: use the groups to find problems and improve the grounding dataset.
The similarity graph also retains links to source URLs. Overlap is unsurprising when many chunks come from related source material, but turning that overlap into explicit relationships makes it available for analysis.
Small friendship diagrams make communities look obvious: one tightly connected clique here, another there. Real graphs look more like tangled spaghetti. In the workshop illustrations, node size represents PageRank and edges carry weights. Community detection supplies a computational way to identify groups within that tangle instead of relying on a visually tidy layout.
Louvain uses modularity optimization. Its intuition is that a community has more internal connectivity than an expected-edge baseline would suggest. Starting with individual node assignments, it tests whether moving a node into a neighboring community improves modularity. It then aggregates the resulting groups and repeats at the coarser level. In the illustrated aggregation, pink and yellow have three edges between them, while pink has 14 internal connections, yellow two, green four and blue 14. The aggregate graph exposes both the strength within groups and the links between them.
The alternatives differ in how they form communities:
| Algorithm | Mechanism to keep in mind |
|---|---|
| Louvain | Improve modularity through local moves and aggregation |
| Leiden | Refine communities to address connectivity problems in Louvain’s output |
| Label propagation | Update labels from neighboring labels over repeated iterations |
Cossette introduces Leiden through connected-versus-unconnected graphs; more precisely, its connectivity guarantee concerns the resulting communities, rather than simply whether the input graph is disconnected. Label propagation is presented as a fast option for large graphs, while other methods may justify more computation when the grouping needs greater nuance. Modularity is the objective used by Louvain here, not a definition of every clustering algorithm.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Project only the data the algorithm needs
Before running KNN, the notebook creates a graph projection: the working graph on which an algorithm operates. An attendee encounters a missing gds.graph.project procedure, but the recorded exchange does not establish its cause. The explanation focuses on the intended projection, named docs, containing document nodes and their embedding property. Excluding unrelated nodes and unnecessary properties keeps the working dataset focused.
At this point in the model, documents connect to assistant responses but do not yet have the document-to-document similarity relationships that KNN will build. The notebook therefore includes an empty relationship setup. Projection output supplies the graph name and node count so the caller can inspect what was created. That separation matters: preparing the working graph is a distinct operation from calculating similarity and storing its results.
The subsequent Explore walkthrough uses similarity relationships that have already been computed and colors nodes by community. Network problems interrupt the live display, but the intended view is clear: clusters of similar documents, with some documents connecting otherwise distinct regions. The visualization is a way to inspect the algorithm’s output, not the mechanism that determines community membership.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A tight cluster can reveal a bad corpus
Some documents act as bridges between regions, motivating the later discussion of betweenness centrality. A two-dimensional embedding view makes the groups easier to survey, though Cossette initially likens it to a bowl of Froot Loops. Zooming in reveals a dense single-community cluster beside a more dispersed area. Which is better? A tight cluster may be desirable in customer segmentation, but in a document corpus it can mean that many chunks say almost the same thing.
The grounding-quality discussion asks whether the material is relevant, adds useful information, is reliable, covers needed knowledge and uses retrieval capacity efficiently. Dispersed retrieval can prompt an investigation into coverage gaps; excessive density can prompt an investigation into redundancy. Once each chunk has a community assignment, summary statistics let you inspect these patterns by group instead of reviewing the entire corpus one document at a time.
One malformed community has a reported median average word length of 512 characters and a median word count of one, in a dataset whose affected chunks are 512 characters long. Those statistics point to something unlike ordinary prose: each chunk effectively behaves like one enormous word. Inspection traces the problem to material ingested from web sources. The workshop dump deliberately retains these artifacts so participants can examine and clean them. Community-level statistics make the odd region stand out.
Community 4702 contains 49 nearly identical chunks with a reported average similarity of 0.98. A top-ten retriever could spend its context budget repeating that one piece of information instead of supplying complementary evidence. The score describes this workshop snapshot; the embedding model and similarity aggregation are not specified in the discussion.
Cossette’s chicken-nuggets-and-Twinkies analogy captures the risk of repeatedly optimizing toward a narrow preference: a household robot feeding children only their favorites would be doing exactly what its feedback rewarded. Similarity-driven retrieval can produce the same narrowing. In an agent chain, an initial signal may then be reinforced at every handoff. Community assignments make another policy possible: rerank a vector result set to include relevant material from additional communities. PageRank can supply a different signal about graph importance. These are choices about the outcomes being encouraged, not just how confidently the nearest matches were found.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Consolidate repeated content while keeping its sources
Versioned documentation explains some of the dense clusters. An algorithm description may remain unchanged between versions 1.5 and 1.6, yet ingestion produces another representation of the same content. Cossette describes collapsing duplicates into a single node while retaining their source relationships. Retrieval then encounters one representation, and the graph still records the places it came from. Reducing duplicate retrieval should not erase lineage.
In the four-node illustration, the text and embedding are the same, so the proposed consolidation keeps one node and the original relationships. Collapse is the conceptual operation described in the recording. The documented apoc.refactor.mergeNodes procedure is an implementation option, but property combination and relationship handling require explicit configuration; it should not be assumed to be the exact workshop call.
The right treatment depends on what must be retained:
- Identical content: consolidate its retrievable representation while preserving source connections.
- Different properties: choose which values to preserve or combine rather than assuming a merge will make the decision correctly.
- Strict retention requirements: consider changing index participation instead of altering the retained records, especially for legal material.
- Different chunk boundaries: inspect the text before merging. An extra paragraph in one version can shift the splitter’s output and prevent otherwise similar pages from producing matching chunks.
The clustering in this exercise applies to document nodes—which are chunks—using their embeddings. It identifies candidates for curation; it does not make every candidate safe to collapse.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Trace where conversations go and what they amplify
With community assignments in place, the application graph supports questions about movement: where conversations begin, where they end and how long they take to reach relevant material. The illustrated conversation retrieves ten context documents per response. Plotting their communities across turns shows a shift from one knowledge area toward another. Conversation length alone is not enough to judge the experience; a short or long journey must be assessed against what the user is trying to accomplish. Cossette presents this as ongoing research into how people move through information, with engineers responsible for the signals their systems amplify.
Importance also has more than one meaning. In the company analogy, a person connected to many influential colleagues and a person connecting two otherwise separate sides of the business can both matter, for different reasons.
| Signal | What it helps investigate |
|---|---|
| PageRank | Importance through the graph’s link structure |
| Betweenness centrality | Positions that bridge paths between regions |
| Community-level ratings | Groups associated with better or worse responses |
Comparing community size with good and bad response ratings helps prioritize which documents deserve review. A poorly rated community may contain outdated or otherwise unsuitable material, even when retrieval reaches it consistently.
Cossette recounts a colleague’s investigation of risk-assessment language repeatedly copied into defense proposals. He traced it to wording from the Vietnam War era. Her point is that repeated use can make stale material appear authoritative: influence tells you what the system is amplifying, while provenance and content review help determine whether it should. A highly reused passage deserves scrutiny because it is influential, not only when it looks anomalous.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Choose where algorithm results live
Built-in GDS algorithms follow a consistent invocation pattern: call the algorithm, identify the projection and choose an output mode. The betweenness-centrality discussion points toward the third notebook. The modes make experimentation and persistence separate decisions:
| Mode | Destination |
|---|---|
stream | Return calculated values for inspection |
mutate | Store results in the in-memory projection |
write | Persist results back to the database |
For example, with a prepared projection named docs, inspecting betweenness scores takes this form:
cypher
CALL gds.betweenness.stream('docs')
YIELD nodeId, score
RETURN nodeId, score
ORDER BY score DESC;
A useful projection for this calculation needs relationships whose paths have the intended meaning. Streaming lets you examine the result before deciding to retain it.
The third notebook introduces a relationship derived from application behavior: co-occurrence. Find the context documents attached to one assistant message, pair distinct documents and MERGE a co-occurs-with relationship. MERGE creates the relationship if it does not already exist. Weighting it by repeated co-retrieval records how often the documents appear together. This can reveal complementary concepts after duplicate content has been reduced; the chunks need not be near-identical to be useful together.
A small Cypher example expresses the pairing operation using an illustrative HAS_CONTEXT relationship from an assistant message to its documents:
cypher
MATCH (m:Assistant)-[:HAS_CONTEXT]->(d:Document)
WITH m, collect(DISTINCT d) AS docs
UNWIND docs AS leftDoc
UNWIND docs AS rightDoc
WITH m, leftDoc, rightDoc
WHERE elementId(leftDoc) < elementId(rightDoc)
WITH leftDoc, rightDoc, count(DISTINCT m) AS sharedMessages
MERGE (leftDoc)-[r:CO_OCCURS_WITH]->(rightDoc)
SET r.weight = sharedMessages;
The ordering condition excludes self-pairs and gives each pair one orientation; that orientation is an implementation convention, not a temporal claim. Recomputing the weight from distinct messages avoids incrementing it merely because the query is rerun. A different derived relationship could represent sequence: these chunks appeared first, then those chunks appeared in a later turn. Such follow-on edges motivate questions about likely next topics or the direction a conversation will take.
For a response with ten retrieved context chunks, all ten participate in that response’s co-occurrence group. They are ten pieces of context, not ten generated answers. Co-occurrence records being supplied together; follow-on relationships record appearing in succession. Keeping those meanings distinct makes their downstream analysis interpretable.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Make traceability part of building the system
Asked about adoption in government and the defense industry, Cossette centers accountability and traceability. She recalls an unnamed political aspirant suggesting that the military must simply learn to trust AI, and responds that verification must accompany trust. Recommendation systems’ unintended echo chambers are her warning: a system can optimize its assigned objective while producing consequences its builders did not anticipate. The answer advocates thoughtful adoption and the rigor of model reports and evaluation; it does not supply an adoption-rate forecast.
Another question approaches the graph from the opposite end: how can developers build one across unfamiliar businesses without already being domain experts? Cossette suggests experimenting with Neo4j’s Knowledge Graph Builder and SimpleKGPipeline. Her conceptual explanation first identifies entities in documents and then asks how they relate. The current experimental pipeline exposes entity-and-relation extraction and configurable schema handling; two separate extraction passes are not a universal API requirement.
Expect the initial result to be noisy. That noise can still be informative: count labels, inspect PageRank and betweenness, and see which structures recur across the documents. The result is a candidate ontology to investigate, not an automatically finished domain model. Even when a schema has already been designed, this exploratory pass may expose valuable concepts that the original design missed.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Carry context across agent handoffs
As content increasingly serves agents as well as people, an audience member asks whether content writers are the primary users of these techniques. Cossette leaves the audience broader and returns to accountability in the loop. A ship with a slightly wrong heading may appear fine initially but drift far from its destination over a long journey. Agent chains can likewise compound an early directional error.
An application graph gives the next agent access to what came before: previous context, retrieved documents and the path through the information space. Cossette proposes studying how quickly activity moves from one community to another as another possible diagnostic. This is an exploratory direction for steering agent chains, rather than a demonstrated autonomous control system.
The content-hygiene question is harder: can graph mathematics identify contradictions or inaccurate source material? Cossette declines to improvise a complete method. She suggests investigating connections and local density, as one might in fraud analysis. Her ElectionGraph example concerns Facebook and Instagram advertising; she recalls its program lead, Jenny, saying that friends-of-friends could be more predictive of voting than immediate friends. No supporting evaluation is supplied for that comparison. Its role here is to motivate looking beyond the nearest neighborhood, not to establish a contradiction detector.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
What communities actually change in retrieval
The final research question asks how to combine semantic embeddings with graph structure when every node has text in the same embedding space. A structural node embedding represents connectivity and relationship context, providing information different from the node’s text embedding. Cossette suggests that the representations can be combined, but does not prescribe a fusion recipe or claim a validated domain-specific approach. PageRank-assisted vector reranking is also named as material the live workshop did not reach.
The last discussion returns to Louvain: assign communities, consider neighboring assignments and test whether the modularity score improves. Tight friend groups provide the intuition, while a person belonging to several groups illustrates a different structural role. The practical question is what those assignments do for a query. Community detection primarily helps engineers curate and understand a corpus at scale. A community label does not have to appear in the generated answer.
Communities can also guide broader context selection when the task calls for it. After someone buys luggage, recommending only more luggage misses complementary purchases; similarly, another near-identical chunk may add less value than a relevant connected concept. Whether retrieval expands that way depends on the retriever’s design and thresholds. Community detection does not automatically fetch every surrounding embedding.
A final audience question asks whether community detection examines only surrounding nodes or nodes across the entire graph. The recording ends the technical exchange without an answer, deferring that discussion until afterward. The operational distinction established before it is the useful one to retain: communities describe the corpus, while the retriever determines how that description changes the evidence supplied to an answer.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Guides to GraphRAG concepts, graph models, data preparation and retrieval patterns.
The original method for organizing chunks into recursively clustered summaries and retrieving across abstraction levels.
Further reading
Procedure syntax and configuration for consolidating nodes, properties and relationships.
Updates since the talk
Current experimental Python guide for constructing knowledge graphs from unstructured documents.
Current vector-index creation and querying documentation, including version-specific filtering capabilities.
Full transcript
Loading transcript…