# Agentic GraphRAG: Simplifying Retrieval Across Structured & Unstructured Data — Zach Blumenfeld

Zach Blumenfeld

AI Engineer World's Fair 2025

[Talk page](https://ai.engineer/talks/CzM3cW6FdBs-agentic-graphrag-simplifying-retrieval-across) · [Video](https://www.youtube.com/watch?v=CzM3cW6FdBs)

## Agentic GraphRAG: Simplifying Retrieval Across Structured & Unstructured Data

An employee assistant needs more than relevant resumes to count skills or find collaborators. A small knowledge graph gives its retrieval tools explicit relationships to query and extend.

Familiarity with embeddings, agent tools, and basic database queries will help; graph concepts are introduced through the employee example.

### Give the agent a model of the data

[0:00](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=0s)

How should an agent retrieve information when part of the answer lives in documents and part lives in structured records? Zach Blumenfeld’s [Neo4j Employee Graph](https://github.com/neo4j-product-examples/neo4j-employee-graph) notebook walkthrough starts with an architecture that puts a **knowledge graph** between those sources and the agent’s retrieval tools. Document extraction brings in unstructured information; standard ETL brings in structured data. Both feed the model the agent queries.

![Architecture diagram showing AI models, a Neo4j knowledge graph, document and table sources, retrieval tools, and a knowledge assistant.](https://ai.engineer/api/talk-essay-media/2d8fe56ad1134b66a8319912bf082f31cd3180f6170f77d95f64951e5e242861)

GraphRAG architecture connects structured and unstructured data to a knowledge graph and agent retrieval tools.

That shared model matters when retrieval becomes a sequence of operations. An agent can decompose a question into several queries rather than make one vector search and answer from its results. A small, explicit data model helps it decide what to retrieve and how the pieces fit together. The model can then grow as additional sources arrive. Here, the starting point is an employee graph.

### Five retrieved resumes are not a workforce count

[2:00](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=120s)

The employee assistant should support skills analysis, team substitutions, collaboration discovery, and identifying skill gaps. Its first source is a folder of PDF resumes for Cyberdyne Systems—the Terminator reference—with professional experience and descriptions of work. Blumenfeld initially loads each resume into Neo4j as a document node containing text, metadata, and an embedding. The database is a graph database, but this first retrieval path treats it as a document store.

An agent built with Google’s [Agent Development Kit](https://adk.dev/) receives instructions to retrieve information and one tool: document search. Asked how many Python developers the company has, it reports five because the retrieval setting is `K = 5`. Blumenfeld explicitly identifies that answer as wrong: the agent has turned the size of its retrieved result set into a claim about the whole workforce. **A retrieval limit is not an aggregation.**

![Notebook output stating there are five Python developers, followed by retrieval criteria and a numbered list of five employees.](https://ai.engineer/api/talk-essay-media/f653e3fa8aa80af31b3c196b74720c86134e486fc1295fbe7fa588cd919f3ba3)

The document-search response reports five Python developers and lists the retrieved employees.

### Similarity, distributions, and collaboration need different operations

[3:56](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=236s)

Entity extraction and additional metadata could help with the counting problem. The next question exposes a different limitation: who is most similar to a particular employee in skills or experience? Lucas is a full-stack AI engineer with Python, JavaScript, and machine-learning experience. The agent uses those descriptions as search terms to retrieve similar resumes. That can find plausible candidates, but the explanation reveals semantic search rather than an explicit, controllable comparison of skill sets.

As the questions broaden, the missing operations become clearer:

| Question | What document search does | What the answer requires |
| --- | --- | --- |
| Summarize technical talent and skills distribution | Retrieves resumes using selected terms | Aggregate skills across employees |
| Find people collaborating on many projects | Searches for collaborators | Connect people through shared projects |

A useful workforce summary needs counts and distributions, not just relevant examples. Likewise, searching for the word “collaborators” does not establish who worked with whom. Resumes may contain that evidence, but the relationships remain buried in text.

### Extract people, skills, and accomplishments

[5:40](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=340s)

The next step is to express the questions’ requirements at the data layer. Start with three concepts: people, skills they know, and things they do. Entity extraction turns the resumes into that graph. The accomplishment model then becomes more specific: someone published, built, won, led, managed, optimized, or shipped something. Those things connect to domains and work types, allowing related activities to meet at shared concepts rather than relying on similar wording.

Blumenfeld uses [Pydantic models](https://pydantic.dev/docs/validation/latest/concepts/models/) and enumerations to define accomplishment types, domains, and work types. A compact Python version of that extraction contract can look like this; the domain and work-type vocabularies here are illustrative:

```python
from enum import Enum
from pydantic import BaseModel, Field


class Action(str, Enum):
    PUBLISHED = "published"
    BUILT = "built"
    WON = "won"
    LED = "led"
    MANAGED = "managed"
    OPTIMIZED = "optimized"
    SHIPPED = "shipped"


class Domain(str, Enum):
    AI = "AI"
    ANALYTICS = "analytics"
    DATA_ENGINEERING = "data engineering"


class WorkType(str, Enum):
    SYSTEM = "system"
    CODE = "code"


class Thing(BaseModel):
    name: str
    domain: Domain
    work_type: WorkType


class Accomplishment(BaseModel):
    action: Action
    thing: Thing


class EmployeeExtraction(BaseModel):
    name: str
    skills: list[str] = Field(default_factory=list)
    accomplishments: list[Accomplishment] = Field(default_factory=list)
```

The schema constrains the structure and allowed values of extraction output. It does not establish whether an extracted skill or accomplishment is factually correct.

The extraction workflow—Blumenfeld recalls using LangChain here—decomposes the documents and produces JSON containing each person’s skills and accomplishments. Loading that JSON into Neo4j creates a more expressive model: people connect through shared skills, the things they worked on, and higher-level concepts describing that work. Those connections become queryable evidence for the assistant’s answers.

### Count and compare through explicit relationships

[8:32](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=512s)

The next agent receives similar instructions plus a description of the graph’s data model. An MCP server gives it access to the schema and supports the Cypher query workflow. The useful division of labor is schema inspection, language-model query generation, and database execution; MCP is the interface connecting those capabilities, not the reasoning mechanism itself.

Now the Python-developer question can match people connected to the Python skill and aggregate the matches. Blumenfeld reports twenty developers from the graph query, describing the result as much closer to correct. That is a result from the demonstration’s extracted graph, not an independently established workforce total. With illustrative labels and relationship names, the operation is:

```cypher
MATCH (person:Person)-[:KNOWS]->(:Skill {name: 'Python'})
RETURN count(DISTINCT person) AS python_developers;
```

The [Cypher aggregation](https://neo4j.com/docs/cypher-manual/current/functions/aggregating/) counts distinct matched people rather than retrieved documents. `DISTINCT` prevents repeated matches for the same person from inflating this count; completeness still depends on the people and skill relationships present in the graph.

The same similarity question—who is most similar to Lucas Martinez, and why?—now returns Sarah. The explanation uses shared skills and the sizes of the compared skill sets; Blumenfeld says some runs also consider similar accomplishments. The useful change is that the comparison refers to inspectable relationships and an overlap calculation, rather than only search-term selection.

That also gives corrections a concrete target. If a person has an incorrect skill relationship, it can be audited and changed in the graph. The assistant can then aggregate those same relationships to summarize how many people know each skill, or break down accomplishments. **The data model makes both the answer and the underlying evidence easier to inspect.**

### Add tools for richer employee comparisons

[10:25](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=625s)

Generated Cypher is not the only retrieval option. Blumenfeld adds specialized tools alongside it, including a query that traverses between person IDs. He describes a zero-to-three-hop traversal that can follow connections through skills, common systems, domains, and accomplishments. This broadens the evidence for similarity beyond a direct skill match.

Because the query explores relationships, Blumenfeld says an added collaboration or project link could also be picked up by that traversal. The scope is still determined by the query’s allowed paths and hop bounds. He also claims flexibility and higher performance for complex graph traversals, but presents no performance benchmark.

![Neo4j graph showing two employee nodes connected through colored intermediate nodes, with Lucas Martinez's properties in a side panel.](https://ai.engineer/api/talk-essay-media/3f75a7e1d46f78529eb0b12d663ee2c1b51300bddb7147fc9c77ac8a660925eb)

A graph query displays connections between employees through shared attributes.

With these tools available, the Lucas Martinez comparison returns more detailed evidence: numbers associated with shared skills and domains such as AI, analytics, and data engineering. The agent can use the retrieved connections to explain how the employees’ work overlaps, instead of giving only a broad statement that their resumes are similar.

### Extend individual accomplishments into shared work

[12:27](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=747s)

The final source is structured internal data from a human resource information system, or HRIS. It describes projects and collaboration among the same people already represented by the resumes. This introduces information the initial extraction model did not capture: multiple employees working on the same thing.

Resume ingestion began with an ownership assumption: a person could have many accomplishments, but each accomplishment belonged to one person because it came from that person’s resume. Shared project records change that relationship to many-to-many.

For the relational design Blumenfeld describes, representing shared ownership would require a join table and a model refactor. In the graph, additional relationships can connect multiple people to shared work. New node and relationship types can also be introduced as sources and agent requirements expand. The existing people and their resume-derived skills remain useful; the new collaboration data adds another way to connect them and another class of questions to ask.

### Find who delivered AI work together

[14:10](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=850s)

A collaboration tool now matches people working on the same thing within selected domains. Asked which individuals collaborated to “deliver the most AI things,” the agent can invoke that operation against shared project relationships. It no longer needs to approximate collaboration by searching resume text for the term.

The resulting answer identifies Sarah Chen and Dr. Amanda Foster and lists their shared AI projects; it also includes other collaboration evidence involving supply-chain work. The final demonstration brings the two sources together: resumes establish skills and individual experience, while structured project records establish shared work. The assistant can answer who collaborated by returning the projects that connect them.

![Rendered notebook answer listing frequent AI project collaborators, two shared projects, other collaborations, and a summary.](https://ai.engineer/api/talk-essay-media/4b7d558e71b1f70af731575e431c3d9912e99a8dbeb74b4343aaa4ae60eead48)

The collaboration response names Sarah Chen and Dr. Amanda Foster and lists their shared AI projects.

## Resources

- [Neo4j Employee Graph](https://github.com/neo4j-product-examples/neo4j-employee-graph) — Employee-assistant notebooks combining resume documents and HRIS records, with Google ADK agents, graph construction and retrieval tools.
- [Agent Development Kit](https://adk.dev/) — Current documentation for building agents with instructions, function tools and MCP integrations.
- [Pydantic models](https://pydantic.dev/docs/validation/latest/concepts/models/) — Define typed Python models and validate, serialize and generate schemas for structured data.
- [Neo4j Labs MCP Servers](https://github.com/neo4j-contrib/mcp-neo4j) — Experimental MCP servers for Neo4j schema inspection, Cypher execution and other graph operations.
- [Cypher aggregation and counting](https://neo4j.com/docs/cypher-manual/current/functions/aggregating/) — Reference examples for graph aggregations, including counts with and without duplicate matches.

## Slides

### Innovation partner and platinum sponsors

[0:10](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=10s) [AWS is the innovation partner; six platinum sponsor logos appear below.](https://assets.ai.engineer/sites/aiecode2025/sha256/9fb4b9bc2e5152b6c0093caa7ea733ca5c0b3517ccb21715e4b5f2e6a19ebebe.webp)

INNOVATION PARTNER
aws

PLATINUM SPONSORS
Graphite
Windsurf
MongoDB®
daily™
augment code
WorkOS

### Neo4j employee graph workshop

The workshop notebooks walk through building a GraphRAG application from structured and unstructured data. The workshop repository is linked in the README.

[0:21](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=21s) [JupyterLab displays the employee graph workshop overview, repository link, and QR code.](https://assets.ai.engineer/sites/aiecode2025/sha256/559431761f6d4a23e5c9cbf92c1c8712743de70e2c37199ed3d5f094bf139ad9.webp)

Neo4j Employee Graph

Link to this repo github.com/neo4j-product-examples/neo4j-employee-graph

This hands-on workshop guides you through building an agentic GraphRAG application and demonstrates the importance of knowledge graphs and graph DBs for grounding AI, particularly in today's new Agentic world with advanced reasoning and diverse tool utilization.

You'll learn how to build a knowledge graph in Neo4j with a combination of unstructured and structured data sources. You will also learn how to build GraphRAG agents utilizing graph retrieval tools (including Neo4j MCP tools) and agents via Google ADK.

Agentic GraphRAG Architecture
AI Models
Embedder
LLM
UI
Knowledge Assistant
Semantic Search, Automation, Personalized Experiences

Interface text:
localhost:8891/lab/tree/README.md
File  Edit  View  Run  Kernel  Tabs  Settings  Help
README  README  resume  project  module  module  extract  person  extract  module
/
Name  Mo...  Size
input-re...  3d ago
resume-...  1h ago
scratch  3d ago
module1...  now  123.8 KB
module2...  1h ago  98.3 KB
module3...  1h ago  37.5 KB
agent.py  3d ago  1.5 KB
AgentRu...  5h ago  2.3 KB
check-p...  3d ago  2.7 KB
extract-r...  3d ago  4.6 KB
extracte...  3d ago  213.9 KB
LICENSE  4d ago  11.1 KB
nb.env  4d ago  330 B
person.py  3d ago  9.2 KB
README...  1h ago  2.4 KB
README.md  1

### Agentic GraphRAG architecture

Documents feed a knowledge graph through entity extraction, while structured tables enter through ETL. Agents use local, drift and global retrieval tools to query the graph for a knowledge assistant.

[0:43](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=43s) [Architecture diagram connects data sources, a knowledge graph, AI models, retrieval agents, and a knowledge assistant.](https://assets.ai.engineer/sites/aiecode2025/sha256/5ea716322b348ba0b872733d070483e0d089192ca6d4875a2ed950ac1534f2a2.webp)

Agentic GraphRAG Architecture

AI Models
Embedder
LLM

UI
Knowledge Assistant
Semantic Search, Automation,
Personalized Experiences

Knowledge Graph
Graph Analytics
Graph Enrichment
(Communities, Entity Resolution, and More)
Entity Extraction
neo4j
Chunk
Entity
Community
Document
MENTIONS
PART_OF
FROM
RELATES_TO
Standard ETL

Agents
Tools
Local Retriever
Graph vector search
Drift Retriever
Dynamic depth graph traversal
Global Retriever
Comprehensive communities
Graph Retrieval
...
Auxiliary Search
specific cases
(RFPs, HR benefits)

Data Sources
Unstructured
Documents...
Structured
Tables...

Other External Services
E.g. Cognitive Search

Interface text:
neo4j-product-examples/neo...
Neo4j Aura
Neo4j Aura
JupyterLab
GraphRAG Structured Unstru...
localhost:8891/lab/tree/README.md
File  Edit  View  Run  Kernel  Tabs  Settings  Help
README  README  resume  project  module  module  extract  person  extract  module
Name  Mo...  Size
input-re...  3d ago
resume-...  1h ago
scratch  3d ago
module1...  now  123.8 KB
module2...  1h ago  98.3 KB
module3...  1h ago  37.5 KB
agent.py  3d ago  1.5 KB
AgentRu...  5h ago  2.3 KB
check-p...  3d ago  2.7 KB
extract-r...  3d ago  4.6 KB
extracte...  3d ago  213.9 KB
LICENSE  4d ago  11.1 KB
nb.env  4d ago  330 B
person.py  3d ago  9.2 KB
README...  1h ago  2.4 KB
README.md  1

### Employee knowledge assistant use case

The workshop starts with PDF resumes and builds an employee knowledge graph combining resume and HRIS information. The assistant’s example questions cover skills, similar people, and collaboration.

[2:00](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=120s) [Workshop page lists skills analysis, person similarities, collaboration questions, and modules.](https://assets.ai.engineer/sites/aiecode2025/sha256/29edb7925c84a2225ffb6b163e1cc8a9b74b1677dfbc4f911ef37db50b4eeb57.webp)

Search

Use Case Example

Employee Knowledge Assistant

Skills analysis, talent search, and team formation at Cyberdyne Systems

• Skills Analysis:
  ▪ How many Python developers do I have?
  ▪ Summarize talent and skills distributions
• Person Similarities: Who is most similar to Lucas Martinez?
• Collaboration & teams: Which individuals have collaborated to deliver the most AI Things?

You'll build an employee knowledge graph combining resume and HRIS information.

Workshop Modules

Module 1: Vector Search with Agents

Learn how to create document nodes with vector indexes in Neo4j and expose to vector search retrieval tools to support agents.

Module 2: Graph Construction and Retrieval

Interface text:
neo4j-product-examples/neo... | Neo4j Aura | Neo4j Aura | JupyterLab | GraphRAG Structured Unstru...
localhost:8891/lab/tree/README.md
File  Edit  View  Run  Kernel  Tabs  Settings  Help
README | README | resume | project | module | module | extract | person | extract | module
Name | Mo... | Size
input-re... | 3d ago
resume-... | 1h ago
scratch | 3d ago
module1... | now | 123.8 KB
module2... | 1h ago | 98.3 KB
module3... | 1h ago | 37.5 KB
agent.py | 3d ago | 1.5 KB
AgentRu... | 5h ago | 2.3 KB
check-p... | 3d ago | 2.7 KB
extract-r... | 3d ago | 4.6 KB
extracte... | 3d ago | 213.9 KB
LICENSE | 4d ago | 11.1 KB
nb.env | 4d ago | 330 B
person.py | 3d ago | 9.2 KB
README... | 1h ago | 2.4 KB
README.md

### Employee Knowledge Assistant use case

The workshop uses resumes and HRIS data to explore skills, similar people, and teams. Blumenfeld plans to start by loading resumes into Neo4j as document nodes with embeddings.

[2:29](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=149s) [JupyterLab README describing skills analysis, person similarities, collaboration, and workshop modules.](https://assets.ai.engineer/sites/aiecode2025/sha256/7884a6a34b1177d6d091c48eb6f988da91453da359a08a6d41d0a07dc9145f35.webp)

Use Case Example

Employee Knowledge Assistant

Skills analysis, talent search, and team formation at Cyberdyne Systems

• Skills Analysis:
  ▪ How many Python developers do I have?
  ▪ Summarize talent and skills distributions
• Person Similarities: Who is most similar to Lucas Martinez?
• Collaboration & teams: Which individuals have collaborated to deliver the most AI Things?

You'll build an employee knowledge graph combining resume and HRIS information.

Workshop Modules

Module 1: Vector Search with Agents

Learn how to create document nodes with vector indexes in Neo4j and expose to vector search retrieval tools to support agents.

Module 2: Graph Construction and Retrieval

Learn how to construct a simple starter knowledge graph from documents to help with agent retrieval tools and improve responses. You

Interface text:
neo4j-product-examples/neo... | Neo4j Aura | Neo4j Aura | JupyterLab | GraphRAG Structured Unstru...
localhost:8891/lab/tree/README.md
File  Edit  View  Run  Kernel  Tabs  Settings  Help
READM... | READM... | resume | project | module | module | extract | person | extract | module
Name  Mo...  Size
input-re...  3d ago
resume-...  1h ago
scratch  3d ago
module1...  now  123.8 KB
module2...  1h ago  98.3 KB
module3...  1h ago  37.5 KB
agent.py  3d ago  1.5 KB
AgentRu...  5h ago  2.3 KB
check-p...  3d ago  2.7 KB
extract-r...  3d ago  4.6 KB
extracte...  3d ago  213.9 KB
LICENSE  4d ago  11.1 KB
nb.env  4d ago  330 B
person.py  3d ago  9.2 KB
README...  1h ago  2.4 KB
README.md  1

### Resume similarity analysis

The notebook searches for skills associated with Lucas Martinez and identifies Elena Popov as the closest match. Blumenfeld notes that semantic similarity can find similar people, but the matching logic is hard to control.

[4:19](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=259s) [Notebook compares two employees by technical skills, roles, and resume similarity.](https://assets.ai.engineer/sites/aiecode2025/sha256/77c29577bf0fc484a0277eabcad075911bbc564904d2005e7edeb54cecce7199.webp)

[11]: display(Markdown(res))

After searching with a prompt highly tailored to Lucas Martinez's background ("full-stack AI engineer Python JavaScript machine learning"), I compared the most relevant resumes based on the following criteria: technical skill overlap, role similarity, and AI/ML exposure.

Among all, the most similar to Lucas Martinez is Elena Popov. Here's why, based on resume data and search logic:

1. Technical Skills Overlap:
• Both are experts in Python and machine learning, which are the core of Lucas's work.
• Elena also has direct AI/ML engineering roles applying Python to production environments and has experience with infrastructure similar to what Lucas has developed.

2. Role and Experience Parallels:
• Elena Popov is a Machine Learning Engineer, which aligns closely with Lucas's Full-Stack AI Engineer title.
• Both have experience building, deploying, and maintaining end-to-end AI solutions.
• Elena has also held roles requiring collaboration across data science, engineering, and production teams, similar to full-stack project demands.

3. Resume Similarity:
• Both have bridged development and machine learning, not purely research or exclusively backend/data roles.
• Elena has built production ML systems and pipelines for high-scale users (personalization AI for 50M+ users, and industrial automation)—similar to Lucas's projects in edtech and healthcare Tech.

While others—such as Sarah Chen and Kenji Tanaka—share strong Python/AI/ML backgrounds, they are less focused on the end-

Interface text:
localhost:8891/lab/tree/module1-vector-search-w-agents.ipynb
File  Edit  View  Run  Kernel  Tabs  Settings  Help
README  README  resume  project  module  module  extract  person  extract  module
Notebook  Python 3 (ipykernel)
Name  Mo...  Size
input-re...  3d ago
resume-...  1h ago
scratch  3d ago
module1...  now  123.8 KB
module2...  1h ago  98.3 KB
module3...  1h ago  37.5 KB
agent.py  3d ago  1.5 KB
AgentRu...  5h ago  2.3 KB
check-p...  3d ago  2.7 KB
extract-r...  3d ago  4.6 KB
extracte...  3d ago  213.9 KB
LICENSE  4d ago  11.1 KB
nb.env  4d ago  330 B
person.py  3d ago  9.2 KB
README...  1h ago  2.4 KB
Python 3 (ipykernel) | Idle  Mode: Command  Ln 1, Col 1  module1-vector-search-w-agents.ipynb

### Technical talent summary

The notebook searches resumes for skill terms and lists employees by discipline. Blumenfeld says search alone cannot aggregate the talent distribution or find relationships between people.

[5:00](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=300s) [Notebook summarizes employee skills in backend architecture and mobile development.](https://assets.ai.engineer/sites/aiecode2025/sha256/e7e6d9d1223444be90bd3949743c3f3232401b291e4d149e8c67d0c369e34310.webp)

In summary, Cyberdyne's technical talent is well-distributed across backend/system architecture, mobile development, analytics/data products, and strong management. There is core strength in Python and Java, significant expertise in cloud and infrastructure, and a blend of senior specialists (James, Miguel, Ahmed, Omar) with a junior pipeline (Alex). This information was retrieved and inferred relevancy based on the depth and recency of experience in each skill area, frequency in the documents, and explicit technologies listed in the resume sections. None None

[14]: display(Markdown(res))

To summarize Cyberdyne Systems' technical talent and skills distribution, I searched employee resumes using the search prompt "technical skills, certifications, expertise, and programming languages." This targeted all relevant technology- and skill-related sections of each resume in the internal database, ensuring high-relevance and comprehensive coverage. Here is a synthesis of the findings, with specific names referenced as instructed:

Backend and Architecture

• Miguel Santos: 10 years backend experience; expert in Python and Java; distributed systems and microservices (event-driven architectures); AWS, Docker, Kubernetes; strong technical and team management background.
• James Mitchell: 12+ years engineering leadership; deep experience in software architecture, large-scale systems, and process improvement; strong background in Python, JavaScript, and AWS; expertise in scaling engineering orgs.
• Ahmed Hassan: Mobile and backend architect; Python and Java on the backend for mobile systems; extensive mobile platform and system design skills.

Mobile Development

• Ahmed Hassan: 9 years iOS, 6 years Android, extensive experience with Swift, Kotlin, React Native, and team management.
• Alex Thompson: Entry-level but focused on Swift/iOS, React Native, and learning Android; demonstrates a pipeline of junior talent being developed.

Interface text:
localhost:8891/lab/tree/module1-vector-search-w-agents.ipynb
File  Edit  View  Run  Kernel  Tabs  Settings  Help
README  README  resume  project  module  module  extract  person  extract  module
Notebook  Python 3 (ipykernel)
Name  Mo...  Size
input-re...  3d ago
resume-...  1h ago
scratch  3d ago
module1...  now  123.8 KB
module2...  1h ago  98.3 KB
module3...  1h ago  37.5 KB
agent.py  3d ago  1.5 KB
AgentRu...  5h ago  2.3 KB
check-p...  3d ago  2.7 KB
extract-r...  3d ago  4.6 KB
extracte...  3d ago  213.9 KB
LICENSE  4d ago  11.1 KB
nb.env  4d ago  330 B
person.py  3d ago  9.2 KB
README...  1h ago  2.4 KB
Python 3 (ipykernel) | Idle
Mode: Command  Ln 1, Col 1  module1-vector-search-w-agents.ipynb

### AI collaboration search

The resume search finds AI collaboration mentions; the speaker wants to identify who worked with whom across projects, information that may be buried in resume text.

[5:21](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=321s) [Notebook lists findings from a search for employees involved in AI product delivery.](https://assets.ai.engineer/sites/aiecode2025/sha256/e09dd0159c47810e16ca18db3790931dac5e11b3df5ffe71780be0bfe8a4f9e0.webp)

This summary was based on depth and frequency of co[illegible]ed, the presence of “AI product delivery” in professional experiences, and explicit ment[illegible] the resumes retrieved using the search_documents tool. None None

[16]: display(Markdown(res))

Based on a targeted search with the prompt "collaboration, AI Things, teams, cross-functional, artificial intelligence, product delivery," I retrieved the resumes of employees involved in AI product delivery, looking specifically for explicit mentions of collaboration on AI projects and productized AI systems.

Key findings from the resumes:

• Rachel Thompson is an AI Product Manager with extensive experience leading cross-functional teams to deliver machine learning and computer vision products, including a medical diagnosis AI, computer vision for radiology, and personalization AI products. Her resume highlights collaborations with ML engineers and significant team leadership, particularly in the healthcare AI domain.
• Omar Ibrahim is a Technical Product Manager who led development for AI-driven credit scoring and machine learning platforms, explicitly mentioning cross-functional AI product development and leading product teams in AI-powered fintech.
• Dr. Amanda Foster is a Research Scientist who has led teams of researchers in state-of-the-art AI for computer vision and NLP, with direct collaboration with engineering teams to turn research into commercial AI products.
• Sarah Chen is a Senior AI Engineer who led an 8-person team developing fraud detection and recommendation AI systems and architected ML infrastructure for large-scale deployment, suggesting close cross-team collaboration to deliver production AI tools.
• Kenji Tanaka is an AI Research Engineer who bridges research and production, collaborating with both research scientists [text cut off]

Interface text:
localhost:8891/lab/tree/module1-vector-search-w-agents.ipynb
File Edit View Run Kernel Tabs Settings Help
README; README; resume; project; module; module; extract; person; extract; module
Name: module2-graph-construction-and-retrieval.ipynb
Path: module2-graph-construction-and-retrieval.ipynb
Last Saved: 6/5/25, 11:02 AM
Last Checkpoint: 6/5/25, 10:45 AM
Notebook; Python 3 (ipykernel)
Name; Mo...; Size
input-re...; resume-...; scratch; module1...; module2...; module3...; agent.py; AgentRu...; check-p...; extract-r...; extracte...; LICENSE; nb.env; person.py; README...
Python 3 (ipykernel) | Idle; Mode: Command; Ln 1, Col 1; module1-vector-search-w-agents.ipynb

### Starting a domain model

A starter graph connects a person to skills they know and things they did, supporting skills analysis, talent search, and team formation.

[5:49](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=349s) [A person node connects to a skill through KNOWS and to a thing through DID.](https://assets.ai.engineer/sites/aiecode2025/sha256/24e27e90ab77343cd617a496b9f961297587f48256edf877ff11e835a9185c66.webp)

We Need More...

Start with a small domain model based on use case and iterate...

Use Case: Skills analysis, talent search, and team formation

Person — KNOWS → Skill
Person — DID → Thing

7

We can think through What type of data model we want given our use case questions:

Interface text:
localhost:8891/lab/tree/module2-graph-construction-and-retrieval.ipynb
File  Edit  View  Run  Kernel  Tabs  Settings  Help
README  README  resume  project  module  module  extract  person  extract  module
Code  Notebook  Python 3 (ipykernel)
Name  Mo...  Size
input-re...  3d ago
resume-...  1h ago
scratch  3d ago
module1...  now  123.8 KB
module2...  1h ago  98.3 KB
module3...  1h ago  37.5 KB
agent.py  3d ago  1.5 KB
AgentRu...  5h ago  2.3 KB
check-p...  3d ago  2.7 KB
extract-r...  3d ago  4.6 KB
extracte...  3d ago  213.9 KB
LICENSE  4d ago  11.1 KB
nb.env  4d ago  330 B
person.py  3d ago  9.2 KB
README...  1h ago  2.4 KB
Python 3 (ipykernel) | Idle
Mode: Command  Ln 1, Col 1  module2-graph-construction-and-retrieval.ipynb

### Expanded people and accomplishments graph

The graph connects people to skills and to things through specific accomplishment verbs. Things also connect to domains and work types, helping link similar accomplishments.

[6:31](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=391s) [A graph connects a person to skills and accomplishments; accomplishments connect to domains and work types.](https://assets.ai.engineer/sites/aiecode2025/sha256/be62085c113150bf77c0e86ea87f0e68556b8e6f184e1cb68d0c97e6bb875878.webp)

Person — KNOWS → Skill
Person — PUBLISHED → Thing
Person — BUILT → Thing
Person — WON → Thing
Person — LED → Thing
Person — MANAGED → Thing
Person — OPTIMIZED → Thing
Person — SHIPPED → Thing
Thing — IN → Domain
Thing — OF → Work Type

document extraction is actually accomplished in extract-resumes-to-people.py which stages structured people with skills and accomplishments in the extracted-people-data.json file. This is done for convenience for the workshop to avoid throttling OpenAI requests.

Interface text:
localhost:8891/lab/tree/module2-graph-construction-and-retrieval.ipynb
File  Edit  View  Run  Kernel  Tabs  Settings  Help
README  README  resume  project  module  module  extract  person  extract  module
Code  Notebook  Python 3 (ipykernel)
Name: person.py
Path: person.py
Last Saved: 6/2/25, 9:39 AM
Last Checkpoint: None
Name  Mo...  Size
input-re...  3d ago
resume-...  1h ago
scratch  3d ago
module1...  now  123.8 KB
module2...  1h ago  98.3 KB
module3...  1h ago  37.5 KB
agent.py  3d ago  1.5 KB
AgentRu...  5h ago  2.3 KB
check-p...  3d ago  2.7 KB
extract-r...  3d ago  4.6 KB
extracte...  3d ago  213.9 KB
LICENSE  4d ago  11.1 KB
nb.env  4d ago  330 B
person.py  3d ago  9.2 KB
README...  1h ago  2.4 KB
Python 3 (ipykernel) | Idle
Mode: Command  Ln 1, Col 1  module2-graph-construction-and-retrieval.ipynb

### Accomplishment and domain types

Blumenfeld uses Pydantic classes for entity extraction, with enumerations naming accomplishment verbs and technical domains.

[7:05](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=425s) [Python enumerations define accomplishment verbs and technical domains.](https://assets.ai.engineer/sites/aiecode2025/sha256/d265e3c26058ac3b6be55817776a5ad1e988d2d68e9b872344f48b519161bee4.webp)

from pydantic import BaseModel, Field
from enum import Enum
from typing import Optional, Dict, Any
from datetime import date

class AccomplishmentType(str, Enum):
    """Accomplishment relationship types (verbs)"""
    BUILT = "BUILT"
    SHIPPED = "SHIPPED"
    LED = "LED"
    PUBLISHED = "PUBLISHED"
    WON = "WON"
    OPTIMIZED = "OPTIMIZED"
    MANAGED = "MANAGED"

# Domain nodes for technical areas
class Domain(str, Enum):
    """Domain categories for technical/business areas"""
    AI = "AI"                           # Machine learning, neural networks, AI systems
    DATA_ENGINEERING = "DATA_ENGINEERING"  # Data pipelines, ETL, data platforms
    ANALYTICS = "ANALYTICS"             # BI, reporting, dashboards, data analysis
    DATABASE = "DATABASE"               # Database systems, storage, optimization
    WEB = "WEB"                         # Frontend, web applications, web platforms
    MOBILE = "MOBILE"                   # iOS, Android, mobile applications
    CLOUD = "CLOUD"                     # AWS, Azure, GCP, cloud architecture
    DEVOPS = "DEVOPS"                   # CI/CD, deployment, automation
    SECURITY = "SECURITY"               # Cybersecurity, auth, compliance
    MICROSERVICES = "MICROSERVICES"     # Service architecture, APIs, distributed systems

Interface text:
localhost:8891/lab/tree/person.py
File  Edit  View  Run  Kernel  Tabs  Settings  Help
Name  Mo...  Size
input-re...  3d ago
resume-...  1h ago
scratch  3d ago
module1...  now  123.8 KB
module2...  1h ago  98.3 KB
module3...  1h ago  37.5 KB
agent.py  3d ago  1.5 KB
AgentRu...  5h ago  2.3 KB
check-p...  3d ago  2.7 KB
extract-r...  3d ago  4.6 KB
extracte...  3d ago  213.9 KB
LICENSE  4d ago  11.1 KB
nb.env  4d ago  330 B
person.py  3d ago  9.2 KB
README...  1h ago  2.4 KB
Python  Ln 1, Col 1  Spaces: 4  person.py

### Thing and accomplishment models

Blumenfeld models a Thing by work type and domain, then connects it to an Accomplishment with a verb and optional details such as impact, role and duration. A subsequent workflow decomposes documents into JSON.

[7:15](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=435s) [Python models define an accomplished thing and its associated accomplishment fields.](https://assets.ai.engineer/sites/aiecode2025/sha256/487c822cf0264ca585f61cce3959a7468f10fca138364b92509370892849c9df.webp)

PROJECT = "PROJECT"         # Time-bounded initiatives
PROCESS = "PROCESS"         # Workflows, procedures
AWARD = "AWARD"             # Recognition, honors
CODE = "CODE"               # Open source, libraries

class Thing(BaseModel):
    """Node representing what was accomplished"""
    name: str = Field(..., description="Unique identifier name for the the thing. "
                                       "This should be unique across all accomplished things and somewhat descriptive."
                                       "Concat the person id to this name to ensure uniqueness across multiple people.")
    type: WorkType = Field(..., description="Type of thing")
    domain: Domain = Field(..., description="Domain/category of thing")

class Accomplishment(BaseModel):
    """Relationship representing an accomplishment"""

    type: AccomplishmentType = Field(..., description="Type of accomplishment (verb)")
    thing: Thing = Field(..., description="What was accomplished")

    impact_description: Optional[str] = Field(None, description="Description of impact/results")
    year: Optional[int] = Field(None, description="Year of accomplishment")
    role: Optional[str] = Field(None, description="Role/capacity in the accomplishment")
    duration: Optional[str] = Field(None, description="How long the accomplishment took")
    team_size: Optional[int] = Field(None, description="Size of team involved")
    context: Optional[str] = Field(None, description="Additional context about the accomplishment")

class SkillName(str, Enum):

Interface text:
localhost:8891/lab/tree/person.py
File  Edit  View  Run  Kernel  Tabs  Settings  Help
Tabs: README, README, resume, project, module, module, extract, person, extract, module
Name  Mo...  Size
input-re...  3d ago
resume-...  1h ago
scratch  3d ago
module1...  now  123.8 KB
module2...  1h ago  98.3 KB
module3...  1h ago  37.5 KB
agent.py  3d ago  1.5 KB
AgentRu...  5h ago  2.3 KB
check-p...  3d ago  2.7 KB
extract-r...  3d ago  4.6 KB
extracte...  3d ago  213.9 KB
LICENSE  4d ago  11.1 KB
nb.env  4d ago  330 B
person.py  3d ago  9.2 KB
README...  1h ago  2.4 KB
Python  Ln 1, Col 1  Spaces: 4  person.py

### Knowledge graph overview

The graph connects people to their skills and the things they work on. Those things connect to higher-level concepts. The results show 60 nodes and 100 relationships.

[7:53](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=473s) [Neo4j displays a graph beside an overview of node and relationship categories.](https://assets.ai.engineer/sites/aiecode2025/sha256/fdf7f061d20e611988f65587b9821f8f3551c60c694a9fbaf9c76a145ce5b3d1.webp)

neo4j$ MATCH p=()-[*]->() RETURN p LIMIT 100

Results overview
Nodes (60)
* (60)
Domain (6)
Person (4)
Skill (17)
Thing (25)
WorkType (8)

Relationships (100)
* (100)
BUILT (18)
IN (25)
KNOWS (26)
LED (3)
OF (24)
OPTIMIZED (1)
PUBLISHED (1)
SHIPPED (1)
WON (1)

Interface text:
console-preview.neo4j.io/tools/query
Graph
Table
RAW
Zoom in
Started streaming 100 records after 44 ms and completed after 61 ms.

### Inspecting a work-type node

The selected SYSTEM node is a WorkType. The graph connects people to skills and the things they work on, which in turn link to higher-level concepts such as systems.

[8:05](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=485s) [A selected work-type node appears in the graph, with its details in a side panel.](https://assets.ai.engineer/sites/aiecode2025/sha256/133981bef88d6f50c315079947fa1350b33279314d8be7199cc5511ca16beaa4.webp)

MATCH p=()-[*]->() RETURN p LIMIT 100

Node details
WorkType
Key  Value
<id>  4:d1805f9b-885c-4575-8474-fe3c00609e7a:80
name  "SYSTEM"

Graph labels:
Kai Wong
Miguel Santos
Fatima Al-Zahra
Dr. Ama-nda Fos...
SYSTEM
TEAM
CODE
PRODUCT
SECURITY
AI
Data Enginee...
Team Manage...
Java
AWS
SQL
Python
Data Analysis
Machine Learnin...
Project Manage...
JavaScript
PyTorch
Comput...
Tensor...
MICROSERVICE...
DATA_ENGIN...
db_monitoring...
db_engineering...
db_performance...
anomaly_detec...
log_analysis_pi...
incident_respon...
security_analyti...
security_analysi...
threat_intellig...
[illegible]_paym...
[illegible]_micro...
[illegible]_fraud...
[illegible]_inven...
[illegible]_web...
[illegible]_rest...
[illegible]_ima...
[illegible]_mul...
[illegible]_nov...
[illegible]_res...

Relationship labels: KNOWS, BUILT, LED, IN, OF

Interface text:
neo4j-product-examples/neo...
Neo4j Aura
JupyterLab
GraphRAG Structured Unstru...
console-preview.neo4j.io/tools/query
Graph  Table  RAW
Started streaming 100 records after 44 ms and completed after 61 ms.

### Querying for a similar person

The agent compares Lucas Martinez’s skills with other people’s skills and ranks them by overlap. The query returns Sarah Chen with six shared skills; Lucas has 11 skills and Sarah has 9.

[9:09](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=549s) [A notebook shows the Python developer count and a query comparing people by shared skills.](https://assets.ai.engineer/sites/aiecode2025/sha256/a0938fd6cc1e1a49b1d0231f09ed27beb8282a7dae0888496dfd9d09048afede.webp)

mpany's knowledge graph. This means these individuals have Python explicitly listed in their skills, ensuring relevance and accuracy from their profile data. None None

[13]: from IPython.core.display import Markdown

display(Markdown(res))

There are 28 Python developers at Cyberdyne Systems.

Retrieval logic: I queried employees who have a direct relationship (KNOWS) to the skill "Python" in the company's knowledge graph. This means these individuals have Python explicitly listed in their skills, ensuring relevance and accuracy from their profile data.

Who is most similar to Lucas Martinez

[14]: res = await db_agent_runner.run("Who is most similar to Lucas Martinez and why?")

None id='[illegible]' args={'query': 'MATCH (p:Person {name: "Lucas Martinez"})-[:KNOWS]->(s:Skill)\nWITH p, collect(s.name) as lucas_skills\nMATCH (other:Person)-[:KNOWS]->(otherSkill:Skill)\nWHERE other.name <> "Lucas Martinez"\nWITH other, lucas_skills, collect(otherSkill.name) as other_skills\nWITH other, apoc.coll.intersection(lucas_skills, other_skills) as shared_skills, lucas_skills, other_skills\nWITH other, size(shared_skills) as num_shared, size(lucas_skills) as lucas_count, size(other_skills) as other_count, shared_skills\nORDER BY num_shared DESC, other.name ASC\nRETURN other.name AS similar_person_name, other.id AS similar_person_id, num_shared, lucas_count, other_count, shared_skills LIMIT 1'} name='read_neo4j_cypher' None
None None will_continue=None scheduling=None id='[illegible]' name='read_neo4j_cypher' response={'result': CallToolResult(meta=None, content=[TextContent(type='text', text='[{"similar_person_name": "Sarah Chen", "similar_person_id": "[illegible]", "num_shared": 6, "lucas_count": 11, "other_count": 9, "shared_skills": ["Python", "Natural Language Processing", "Docker", "Machine Learning", "AWS", "Computer Vis

Interface text:
localhost:8891/lab/tree/module2-graph-construction-and-retrieval.ipynb
File Edit View Run Kernel Tabs Settings Help
README, README, resume, project, module, module, extract, person, extract, module
Code; Notebook; Python 3 (ipykernel)
Name; Mo...; Size
input-re...; resume-...; scratch; module1...; module2...; module3...; agent.py; AgentRu...; check-p...; extract-r...; extracte...; LICENSE; nb.env; person.py; README...
Python 3 (ipykernel) | Idle; Mode: Command; Ln 1, Col 1; module2-graph-construction-and-retrieval.ipynb

### Similarity result

The graph ranks Sarah Chen closest to Lucas Martinez by shared skills: six overlap, out of Lucas’s 11 and Sarah’s 9. The next query asks for a technical talent and skills distribution.

[9:17](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=557s) [A notebook explains a similarity result based on six shared skills.](https://assets.ai.engineer/sites/aiecode2025/sha256/74fb22b5cec00edc93801cb223825cd4d8d3a57dcb747e2200c182030f6ab93c.webp)

similarity by the count of shared skills. None None

[15]: display(Markdown(res))

The most similar person to Lucas Martinez is Sarah Chen (ID: [illegible]).

Reasoning and explanation:
- I searched for people in the knowledge graph who are not Lucas Martinez and compared their skill sets.
- I calculated similarity based on the number of overlapping skills (using set intersection).
- Sarah Chen has the highest number of shared skills with Lucas Martinez—6 in total: Python, Natural Language Processing, Docker, Machine Learning, AWS, and Computer Vision.
- Lucas has 11 skills, Sarah has 9, and they overlap on 6, making the overlap significant.

This inference is directly from the database by finding whose skills most closely match Lucas's, measuring similarity by the count of shared skills.

Summarize my technical talent and skills distribution

[16]: await db_agent_runner.restart_session()
Session [illegible] ended successfully
Session started successfully with ID: [illegible]

[17]: res = await db_agent_runner.run("Summarize my technical talent and skills distribution?")
None id='[illegible]' args={} name='get_neo4j_schema' None
None None will_continue=None scheduling=None id='[illegible]' name='get_neo4j_schema' res[illegible]

Interface text:
localhost:8891/lab/tree/module2-graph-construction-and-retrieval.ipynb
File Edit View Run Kernel Tabs Settings Help
Notebook; Python 3 (ipykernel)
Name; Mo...; Size
input-re...; resume-...; scratch; module1...; module2...; module3...; agent.py; AgentRu...; check-p...; extract-r...; extracte...; LICENSE; nb.env; person.py; README...
Python 3 (ipykernel) | Idle; Mode: Command; Ln 1, Col 1; module2-graph-construction-and-retrieval.ipynb

### Technical talent and skills distribution

The notebook counts employee-to-skill relationships in the knowledge graph. Python leads with 28 people, followed by SQL with 16 and AWS with 15.

[10:11](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=611s) [A notebook summarizes skill counts across programming, cloud, leadership, data, AI, and DevOps.](https://assets.ai.engineer/sites/aiecode2025/sha256/550a67dda15d5231bc10cdddf32857c8b62fa4d824ddae621cc97689893ae83b.webp)

If you'd like a breakdown by department, level, or experience range, let me know! None None

[18]: display(Markdown(res))

Summary of Technical Talent and Skills Distribution

I analyzed the skills distribution among all technical employees at Cyberdyne Systems by counting the number of people who "KNOW" each skill. This was found in the knowledge graph, which directly connects Person nodes with their respective Skill nodes.

Main findings:
- The most common skills are programming languages and cloud infrastructure: Python (28 people), SQL (16), AWS (15).
- Leadership and collaborative skills are also highly present: Team Management (14), Project Management (11), Leadership (6).
- Data and AI skills are well-represented: Machine Learning (11), Data Engineering (8), Computer Vision (7), Deep Learning (6), Natural Language Processing (6), TensorFlow (6).
- DevOps skills like Docker (10) and Kubernetes (9) are common, indicating readiness for modern deployment practices.
- Frontend and backend technologies such as Java (6), JavaScript (6), React (5), Go (4), and Node.js (2) show full-stack capabilities.

The data came from direct relationship counts in the graph database, reflecting how many employees have indicated each skill in their profiles. This provides a high-quality, accurate measure of talent concentration in each technical area, based on explicit skill declarations.

If you'd like a breakdown by department, level, or experience range, let me know!

Interface text:
neo4j-product-examples/neo...; Neo4j Aura; Neo4j Aura; module2-grap... (6) - Jupyter; GraphRAG Structured Unstru...
localhost:8891/lab/tree/module2-graph-construction-and-retrieval.ipynb
File  Edit  View  Run  Kernel  Tabs  Settings  Help
README; README; resume; project; module; module; extract; person; extract; module
Code; Notebook; Python 3 (ipykernel)
Name  Mo...  Size
input-re...  3d ago
resume-...  1h ago
scratch  3d ago
module1...  now  123.8 KB
module2...  1h ago  98.3 KB
module3...  1h ago  37.5 KB
agent.py  3d ago  1.5 KB
AgentRu...  5h ago  2.3 KB
check-p...  3d ago  2.7 KB
extract-r...  3d ago  4.6 KB
extracte...  3d ago  213.9 KB
LICENSE  4d ago  11.1 KB
nb.env  4d ago  330 B
person.py  3d ago  9.2 KB
README...  1h ago  2.4 KB
Python 3 (ipykernel) | Idle
Mode: Command  Ln 1, Col 1  module2-graph-construction-and-retrieval.ipynb  1

## Full transcript

[0:00](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=0s) [upbeat music] I'm gonna go over today GraphRAG, particularly dealing with multiple data sources, uh, so both unstructured and structured data sources and kind of why you would wanna ever do that in the first place even.

[0:25](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=25s) So I prepared, uh, some notebooks here. I was gonna make slides, but then I thought it would just be easier to walk through some of what this looks like in practice.

[0:34](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=34s) Um, so there's a link here, and I can share it with you at the booth later, um, if you have follow-up questions. But basically, uh, what I wanted to show you first is just what a general GraphRAG architecture looks like.

[0:46](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=46s) Right? And so basically what we do is we have our agents, right, we have our tools, just like you normally would, but then in the middle here, you see off to the side, we have this knowledge graph.

[0:56](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=56s) And this knowledge graph you can ig- both extract data from documents and unstructured places and also have standard ETLs for structured data. And so there's a big question of why in the hell you would want this knowledge graph thing sticking in the middle there.

[1:10](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=70s) And I could talk about accuracy and explainability, but I think what's really valuable to talk about is kind of what this means going forward with agents and how it's valuable for agentic workflows.

[1:20](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=80s) And as we think about some of what agents can do with reasoning and decomposing questions, a lot of the retrieval that we're seeing is not so much just a straight shot vector search anymore.

[1:32](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=92s) A lot of what we're seeing is a question being broken down and being handed multiple queries, right, to go and pull the data that you need. And the great thing about having a knowledge graph is that you can express a very simple data model to get started to your agent, which can help it do that decomposition, pull

[1:48](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=108s) information accurately, and then as you sort of expand, you can keep adding more and more data. The example that I'm gonna show you here inside of these notebooks is gonna be for a, uh, employee graph.

[2:00](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=120s) So basically, think about a knowledge assistant that's responsible for helping pull information around skills analysis, um, look for similarities or substitutions in a team and try to figure out who's collaborating, where skill gaps are, all that sort of stuff.

[2:14](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=134s) And the data that we're gonna start with today is just gonna be in resumes. I just have these PDFs, just like a folder of resumes, um, that are pretty standard.

[2:22](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=142s) It just lists people's professional experience and descriptions. Um, it's for a company called, uh, what did we have here? Cyberdyne Systems, if anyone's familiar with them.

[2:35](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=155s) A little Terminator reference. All right. Um, so anyway, the first thing that I'm going to do to just show you what this looks like is I'm going to load documents into the Neo4j Graph database, but just sort of as, like, basically documents.

[2:50](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=170s) Chunk, basically take every resume, put an embedding on it. What it looks like here if I was to, if I was to scroll here, is kinda like this. So basically, you know, I have these different nodes, but you'll see the nodes are basically just gonna have some metadata, some text, which is the resume, and then an embedding.

[3:08](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=188s) And basically what I'm going to do is I'm just gonna create an agent inside of ADK, so Google's framework, and I'm gonna start asking it some of those questions.

[3:17](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=197s) And so basically what you're gonna see here, and I don't have time, unfortunately, to walk through all of the code, but basically if you look at this agent that's been constructed, right, I have my agent, I have some instructions to pull data, and then I give it one tool, which is a tool to go search documents, right?

[3:34](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=214s) And so I'm gonna ask it a question: How many Python developers do I have? You can imagine, right, this is probably not gonna work out very well if all I have is just documents.

[3:44](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=224s) Because basically it's gonna tell me I have five Python developers. And that's because I set K equal to five, right, when I went to go pull my documents. So obviously that's gonna be wrong, and I'm telling you that that answer, that answer is wrong.

[3:56](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=236s) So you could probably solve that with doing some entity extraction and putting more metadata, right, on your nodes. So that's, so that's fine. So then I'm gonna ask who is most similar to a particular person in terms of just their skill set or what they've done.

[4:09](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=249s) Um, and again, here what you'll see, and I've told it in the bottom to kind of explain what it's doing, um, if I go down to the display here, um, it, it'll tell me basically here that what it's doing is it's just gonna be using search terms to go pull information.

[4:26](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=266s) So this might help you find similarity to a certain extent. Like, it knows, you know, Lucas is, is a full stack AI engineer and he does, you know, Python, JavaScript, and some machine learning stuff, I guess.

[4:37](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=277s) Um, so you can search for that and you can find some similar people, but the logic is still a little bit hard to control. It's just sort of, you know, plain semantic similarity search.

[4:46](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=286s) Um, and as I start to go down, I can ask questions like, summarize my technical talent and skills distribution. It's not gonna be able to answer that, right? 'Cause it needs to be able to do an aggregation to answer a question like that.

[4:57](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=297s) So if I was to go up and look at the logic again, or I'll go down here, um, it could say I search, you know, employee's resumes using certain search terms and stuff, right?

[5:06](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=306s) And so it's basically if I go down and ask these questions, it's just gonna be using search terms to find things. And so that's not really good enough for our use case because we wanna do analytics, we wanna do aggregations, and we wanna try to find relationships between people.

[5:20](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=320s) Um, and again, like in the last question, I basically asked it to find who's collaborating on lots of projects, and alls it can do is search for collaborators, which is not really what I want.

[5:29](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=329s) Like, what I want is to find who's been collaborating with who on different projects, right? And the resume data, you know, might have that, but it's all, you know, sunk inside of the text and stuff, so, so it can't really do that.

[5:40](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=340s) So the question is now, well, how do I think about basically explaining my data to my agent and then also making sure, right, that I have a data model that makes sense?

[5:51](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=351s) So if you think about it, you can do this at the data layer. You can think about, how do I wanna model my data just to start for some of these beginning questions?

[6:00](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=360s) And here it's basically like I wanna know what a person is, so I need that. I want some concept of a person knowing skills, and then the only other thing that I really care about is what do people do?

[6:13](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=373s) Like, what things do they do, right? Very simple. That's just the data model that I want to express. So I'm gonna do entity extraction of these documents to basically create this graph.

[6:24](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=384s) And really, it's gonna be just slightly more complicated than that because basically what I need to do here is I actually need to create a graph where, right, I have instead of just doing things, I have publish, built, won, led, managed, optimized, shipped things, and then those things are gonna belong to different domains and work types, um,

[6:46](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=406s) which is gonna allow me to kinda connect similar things together inside of the graph. So it's, it's a little bit more complicated, but it's, it's the same exact concept.

[6:56](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=416s) Um, and basically the entity extraction workflows we use, um, are pretty, um, self-explanatory. They use, um... If I was to go here, I use Pydantic classes to do that.

[7:08](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=428s) So I have concept of enumerations on the types of accomplishments and domains that I want and work types as well. I define my things. I define how someone does a thing through an accomplishment.

[7:19](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=439s) Um, and then basically I put that through, um, another workflow. Um, I think I use LangChain in this case, uh, to basically decompose those documents and spit out a bunch of JSON.

[7:31](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=451s) And inside of that JSON, for example, for this person, I have their skills, right, that I get in here, and I also have their accomplishments that I get inside of here.

[7:40](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=460s) Um, so I can go ahead and load that as well into my graph, and now I have a much more expressive data model. So if I go back to here and scroll up

[7:54](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=474s) and look at this guy, this is now kind of what my data model looks like, right? I have my people, but now you see how they're connected by all of these different skills that they have, as well as the things that they're actually working on and how those things connect to higher level concepts like whether it's, you

[8:10](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=490s) know, um, building something for a system or shipping code, doing all those sorts of things. And now, because I have that expressive data model, I'm able to start having a lot more precision around the way that I get my questions, uh, basically answered.

[8:27](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=507s) So what I do here, after all this graph construction, which I already talked through,

[8:32](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=512s) is I create this other agent, give it a similar set of instructions. I tell it a little bit about my data model in here, and then I'm actually gonna be using this MCP server that allows it to read the schema and also generate Cypher statements.

[8:48](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=528s) Um, so this is an MCP tool that we just have, you know, out on GitHub that you can pull. Now, when I ask how many developers I have, now I can actually do a query that's gonna match on person node skill Python.

[9:01](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=541s) And because of that, I get an answer that's much closer to correct, which is twenty developers, right? That's very simple. That's just aggregation. But now I can ask a similarity question, right, like I did before.

[9:12](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=552s) Who is most similar to Lucas Martinez, and why? So this is the same exact question. And when I went to go, uh, calculate that, I got an answer that it's Sarah.

[9:23](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=563s) And it will explain the reasoning that it did. It searched for people w-- who knew, um, the same skill sets. Sometimes when I ask this, it will also search for people who have similar accomplishments as well.

[9:34](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=574s) Um, and it will explain exactly like, "Hey, like I did an overlap calculation in the graph to figure out basically, you know, given the number of skill sets they had and the number of overlap, this is the person that I think is the closest."

[9:47](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=587s) So the benefit of doing this is that you have much more control, and you can go in and filter exactly what skills people have. So, for example, if I knew someone actually didn't have a certain skill or did have a certain skill, I can audit that.

[9:59](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=599s) I can adjust the graph to be able to make that work. Um, and then similarly, as we go down, to summarize a technical talent distribution, um, again, I can match on those skills, and I can start to answer these questions and actually get numbers between how many people know different skills.

[10:16](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=616s) Um, and it can also break down different accomplishments and other things of that nature. So you just get much more refinement in the types of answers, uh, that you get for your questions.

[10:25](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=625s) Um, I can also add additional tools. Uh, so instead of just generating, uh, Cypher kind of, um, on the fly with the language model, I can also-- and I'll show you what some of these look like in, uh, my bigger screen here.

[10:42](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=642s) I can go ahead and, uh, move this up.

[10:48](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=648s) So this is an example of finding people with similar skills here that I'm about to show you. And basically, right, I can do these very flexible queries in a graph database where I can say, "Hey, go from person ID to this other person ID."

[11:04](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=664s) And as I do that, basically what I'm saying in that top syntax there is go out some, you know, zero to three hops, basically. And so what that allows me to do is I can traverse over both the skills, over the common systems, over the common domains they work at and all of their accomplishments.

[11:21](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=681s) Um, and if I wanted to add something else to that data model, maybe there's a collaboration link or another project link, that would all get picked up inside of that query.

[11:29](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=689s) So there's a lot of flexibility and also higher performance, um, in a graph database when you start wanting to do those types of complex traversals. Um, and that allows me then, when I go to find similar people again.

[11:42](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=702s) So if I was just to scroll down to my, uh, question where I define my agent again, I give it more tools, and then I can actually look at who is most similar to Lucas Martinez and why, and it will start doing these queries.

[11:56](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=716s) So what you see it get back is, like, all of the results of what I was just showing you earlier. And what that will help with, if I scroll down to the response, is now what will help me get all of these specific numbers around the skills and then also the domains now, um, between the different AI

[12:12](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=732s) and analytics and data engineering and things that they were working on. So there's more explainability with the way that these questions are being, uh, answered. The last part that I wanted to show you, and I only have a few minutes left, so I'm gonna go very quick, is what happens now when you wanna add more data to

[12:27](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=747s) your graph, right? So basically, say that we had this resume data, but now we have this internal data that comes from a human resource intelligence system, and this tells me different projects that people are working on together and collaborating on.

[12:41](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=761s) So I have basically the same people that came from, uh, resumes earlier, but now I can see different projects that they were working on together. And the great thing about graph is that ll- it allows you to add these things very flexibly.

[12:54](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=774s) So if I go back to my, um, to my notebook here, when you expand a data model with something like if you're, if you're in sort of RDBMS or tables, one of the assumptions that I made when I was ingesting the resumes initially was it was one person...

[13:10](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=790s) an accomplishment only had one person. It was sort of this one-to-one relationship, or really it was one to many, but an accomplishment only had one person because it was just listed on the resume.

[13:20](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=800s) But now that I, um, am doing this thing with this internal system, I can actually see people who are, uh, co-collaborating, and what that would mean in a tabular environment is I would have to create another join table, right?

[13:32](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=812s) So I'd have to do some sort of data model refactor. But the great thing about graph is that I don't have to do that at all. I can just sort of create new relationships.

[13:42](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=822s) So this is very useful when you're going from one to many to many to many, or when you're introducing completely new node and relationship types. It's very easy to do that, which is super important as we move very, very fast, right, with our agents, and we wanna ingest new data quickly and kind of build out our systems

[13:57](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=837s) and pivot and all that sort of stuff. Um, and once I have that information, right, I can start asking questions about who's collaborating with each other. Um, so what I'm gonna do is I'm gonna create...

[14:10](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=850s) This is sort of what the tool creation looks like. This is a lot of the same tools that I had before. Um, but the tool that I can create here to find collaborators will basically do this match, um...

[14:22](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=862s) It's all the way down here. It will do this match to find people who are working on the same thing, um, within a certain set of domains. Uh, so that's kind of what the graph looks like that I get returned.

[14:32](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=872s) And when I-- Now, when-- Since I've added that tool, basically what it means is that when I ask a question, like which individuals have collaborated with each other to, and this says, "Deliver the most AI things," right, it can go ahead and leverage that tool, um, and then it can now return an answer that's much more, um,

[14:52](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=892s) you know, exact and based on my data. So now I know that Sarah and Amanda have accompl-- have collaborated on very specific, um, projects, and as well as I have other collaborators here with supply chain and such.

[15:06](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=906s) Uh, so that was my short presentation. I hope it was helpful. Uh, if you have any more questions, I would be happy to meet you at the booth, and we can talk more.

[15:14](https://www.youtube.com/watch?v=CzM3cW6FdBs&t=914s) Um, but that's it for me today. Thank you, everyone. [clapping] [outro jingle]
