What You Will Learn

• Identify limitations of vanilla RAG and when it fails
• Design agentic reasoning to choose retrieval tools
• Build and query knowledge graphs with Neo4j and Graffiti
• Integrate Postgres+PGVector with a graph for hybrid retrieval
• Configure ingestion, prompts.py, API/CLI and Claude Code workflows

Study Guide

Introduction: Why This Course Matters

There’s a hidden cost to information overload: you ask a question, and your AI spits back an answer from a static list of “relevant” text chunks. It works,until it doesn’t. What if you want connections, synthesis, or a real understanding of how knowledge fits together? That’s where RAG 2.0 arrives: a fusion of agentic reasoning and knowledge graphs, built for those who don’t just want answers,they want insight.
This course will take you from the basics of traditional Retrieval Augmented Generation (RAG), through its limitations, into the world of Agentic RAG, and then deeper, showing you how to marry agentic reasoning with knowledge graphs. You’ll get a blueprint for building an intelligent, flexible retrieval system, and a free template to kickstart your own projects. Every step is demystified, practical, and actionable,whether you’re a developer, product owner, or an AI enthusiast ready to level up.

Traditional (Vanilla) RAG: The Foundation and Its Limits

Let’s start at the roots. Traditional RAG,sometimes called “vanilla” or “naive” RAG,is deceptively simple: take your documents, break them into chunks, embed each chunk as a vector, and toss those vectors into a database. When someone asks a question, you embed the query, grab the most similar document chunks, and hand them to your language model for an answer.
It’s the Google of AI: fast, surface-level, and direct. But here’s where the cracks appear:

• Inflexibility: The process is rigid. The agent has no say in what information it sees; it gets only what the vector search delivers, whether or not it’s the best fit. The agent can’t ask clarifying questions, refine its search, or pick a different tool.
• Limited Exploration: If your query needs deeper understanding,like exploring relationships, drawing inferences, or combining sources,vanilla RAG just can’t do it.

Example 1:
A user asks, “What are Google’s AI initiatives?” Vanilla RAG retrieves chunks mentioning Google and AI, then feeds them to the LLM. It works for straight lookups.
Example 2:
A user asks, “How are OpenAI and Microsoft related?” The vector search might return chunks mentioning both, but it can’t synthesize their business relationship or uncover how their initiatives overlap.

Tips and Best Practices:
- Use vanilla RAG for simple, direct questions where semantic similarity is enough.
- Recognize its limits: if your use case involves multi-hop reasoning, relationships, or synthesis, you’ll hit a wall.

Agentic RAG: Flexibility Through Reasoning

Agentic RAG is a paradigm shift. Instead of force-feeding context to your language model, you empower your agent to reason about its information sources. The agent can decide: “Should I query the vector database, the knowledge graph, or both? Should I refine my search or ask a follow-up question?”
This is AI with agency,AI that thinks about how it thinks.

• Reasoning About Tools: The agent can choose between multiple data sources (vector database, knowledge graph, web search, etc.) depending on the query.
• Flexible Exploration: The agent can chain queries, perform multi-step searches, or combine different sources to build an answer.

Example 1:
A user asks, “What are the AI initiatives for Google?” The agent recognizes this is a direct lookup,vector database is the best tool.
Example 2:
A user asks, “How are OpenAI and Microsoft related?” The agent realizes this is about relationships and switches to the knowledge graph to map connections.
Example 3:
A user asks, “What are the initiatives for Microsoft? How does that relate to Anthropic?” The agent combines tools: it retrieves initiatives from the vector database, and then uses the knowledge graph to find links between Microsoft and Anthropic.

Tips and Best Practices:
- Define clear reasoning rules for your agent: when to use which tool, and how to combine results.
- Structure your project so new tools can be added as your needs evolve.

The Power of Combining Agentic RAG and Knowledge Graphs

Here’s where things get exponential: agentic reasoning lets your AI pick its tools, and knowledge graphs give it a map of relationships. Combined, they create a system that does more than retrieve facts,it understands context, connections, and meaning.
Why does this matter? Because not all information is created equal:

• Vector Database Strengths: Perfect for direct lookups,“tell me about this company,” “show me this initiative.” It shines where semantic similarity is king.
• Knowledge Graph Strengths: Built for relationships,“how are these two companies connected?” “show me the partnership network between AI labs.” It’s about mapping the web of entities and their links.
• Agent’s Reasoning: The real leap is letting the agent decide. For simple lookups, it goes vector; for relationships, it pivots to the graph; for complex queries, it orchestrates both.

Example 1:
Query: “What are the AI initiatives for Google?” Result: The agent uses the vector database, finds the relevant chunks, and delivers an answer.
Example 2:
Query: “How are OpenAI and Microsoft related?” Result: The agent queries the knowledge graph, traces partnership nodes, and provides a relational answer.
Example 3:
Query: “What are the initiatives for Microsoft? How does that relate to Anthropic?” Result: The agent pulls initiatives from the vector database, then cross-references the knowledge graph for connections to Anthropic,delivering a synthesized, multi-source answer.

Practical Applications:
- Company intelligence platforms: See both what a company does (vector) and who they’re connected to (graph).
- Research assistants: Uncover not just facts, but the story behind the facts,collaborations, influence networks, and trends.
- Internal knowledge bases: Employees get answers that show both content and context, boosting understanding and decision-making.

Best Practices:
- Always let your agent explain its reasoning,“I used the knowledge graph because your question was about relationships.”
- Design your system so each tool can evolve independently (swap out the vector DB or the graph engine as needed).

Technical Stack and Implementation Details

You want to build this for real? Here’s the blueprint. The stack is modular, open, and built on proven tools:

• AI Agent Framework: Pydantic AI. Organizes your agent logic, making it easy to build, test, and extend.
• Knowledge Graph Library: Graffiti. Handles the mapping of entities and relationships, sitting on top of Neo4j.
• Knowledge Graph Engine: Neo4j. The backbone for storing and querying relational data.
• Vector Database: PostgreSQL with PGvector extension, hosted on Neon. Stores and indexes your embeddings for fast similarity search.
• API Layer: FastAPI. Lets you expose your agent as an API endpoint for easy integration.
• AI Coding Assistant: Claude Code. Automates coding, planning, database setup, and testing.
• LLM Providers: OpenAI (GPT-4.1 Mini default), OpenRouter, Ollama (for local/offline LLMs), Gemini. Flexibility to use the best model for each part of your stack.
• Embedding Models: OpenAI’s text-embed-3-small (default), but you can swap in alternatives like Ollama or Gemini as needed.
• Data Ingestion LLM: Typically a lightweight model (e.g., GPT-4.1 Nano) that transforms documents into entities and relationships for the knowledge graph.

Implementation Steps,In-Depth:

1. Prerequisites: Make sure Python, PostgreSQL (Neon recommended), Neo4j (local or desktop), and an LLM provider API key are ready.
2. Environment Setup: Create a virtual environment, install dependencies with pip, and clone or download the template.
3. SQL Database Configuration: Run the provided SQL scripts to set up PostgreSQL for vector storage. Adjust the vector dimensions if you use a different embedding model (e.g., 1536 vs. 768).
4. Neo4j Setup: Install Neo4j (either via a local AI package or desktop application), and note your username and password for connection.
5. Environment Variables: Configure a .env file with your database URLs, LLM provider details, API keys, and chosen models.
6. Document Ingestion: Place markdown documents in the documents folder. Then run python -m ingestion.ingest --clean to process them. This command wipes and recreates the vector and graph tables, chunks and embeds documents for the vector DB, and uses an LLM to extract entities and relationships for the knowledge graph.
7. Agent Behavior Configuration: Edit prompts.py, which contains the primary system prompt that tells your agent how to reason: when to use which tool, and how to synthesize answers. This is where your agent’s “brain” lives.
8. API Server and CLI: Start the API with python -m agent.api. Use python cli.py in another terminal to interact with your agent through the command line.

Example 1:
You’re ingesting a new batch of industry reports. You drop them in the documents folder and run the ingestion script. The vector database instantly fills up. The knowledge graph takes longer,each document is parsed by the LLM to define entities and relationships.
Example 2:
You want to test different LLM providers. You simply change the environment variable for the LLM API key and rerun the ingestion or main agent process.

Tips and Best Practices:
- Always clean your database with the --clean flag when starting a new project or after major schema changes.
- Monitor the time/cost of knowledge graph ingestion,it’s LLM-heavy and takes minutes per document, not seconds.
- Keep prompts.py under version control; it’s as important as your code.

Document Ingestion: How the System Learns

The ingestion process is the engine room of your knowledge base. Here’s how it works:

• Vector Database Insertion: Documents are chunked (split into manageable pieces), embedded, and inserted,this is fast and scales well.
• Knowledge Graph Creation: Each document is parsed by an LLM, which extracts entities (people, companies, projects) and relationships (“partnered with,” “acquired by,” “collaborated on”). These are added to the graph,this is computationally expensive and takes much longer.

Example 1:
Embedding a single whitepaper into the vector database: 5 seconds.
Building the knowledge graph for the same document: 2-3 minutes (depending on LLM speed and document complexity).

Tips and Best Practices:
- Use a smaller, cheaper LLM for ingestion where possible.
- Ingest documents in batches to optimize LLM calls and manage compute costs.
- If you change embedding models, update the vector dimensions before ingesting.

System Prompts: Programming the Agent’s Mind

The prompts.py file is your agent’s “operating system.” It tells the agent:

• When to use the vector database vs. the knowledge graph
• How to interpret and combine results from different sources
• What reasoning steps to follow when faced with ambiguous queries

Example 1:
You write a prompt: “If the question is about relationships, use the knowledge graph. If it’s a direct lookup, use the vector database.”
Example 2:
For a demo, you make the instructions explicit for transparency. For production, you might make them implicit to allow the agent more freedom.

Best Practices:
- Iterate on your prompts,test, tweak, and refine until your agent’s reasoning matches your expectations.
- For demonstrations, keep instructions explicit so users can follow the agent’s logic.
- For production, allow more implicit reasoning to encourage robust, adaptable behavior.

Claude Code: The Agentic AI Coding Assistant

Building a system like this is complex. Claude Code is your AI coding copilot,an agent that plans, codes, tests, and manages your databases.

• MCP Servers: Claude Code can interact with external services,like creating projects on Neon, running SQL queries, or pulling documentation into its context.
• Crawl for RAG MCP: Lets you point Claude Code to external docs (e.g., Pydantic AI) to boost its knowledge for your project.
• Neon MCP: Claude Code can set up your Neon project, run SQL, validate schemas, and manage tables automatically,no manual database setup needed.
• Agentic Process: Claude Code works in a loop,planning, executing, testing, and iterating with your approval.

Example 1:
You start a new project. Claude Code asks questions, builds a project plan, and generates a task list. Then it runs through those tasks, setting up your database, writing ingestion scripts, and building your API endpoints,all in one shot.
Example 2:
You drop your previous project’s scripts into an examples folder. Claude Code uses them as references for best practices, especially for complex setups like Graffiti or Pydantic AI agents.

Key Workflow Files:
- claw.md: Global rules for Claude Code,how it uses planning/task docs, MCPs, and unit testing.
- planning.md: The “bird’s-eye view”,architecture, components, stack, and design principles.
- task.md: The granular to-do list,tasks Claude Code checks off as it goes.

Best Practices:
- Use Claude Code’s plan mode (Shift + Tab twice) to brainstorm and scope before building.
- Approve major actions manually, especially database changes.
- Keep examples up to date,Claude Code learns from your best work.

How to Build and Run Your Agentic RAG System,Step By Step

Let’s walk through the process of spinning up your own Agentic RAG + Knowledge Graph system:

1. Prepare Your Tools: Install Python, set up PostgreSQL (Neon is easiest), and install Neo4j locally or via desktop. Get your API keys for your preferred LLM provider.
2. Set Up Your Python Environment: Make a virtual environment, activate it, and pip install requirements.
3. Configure Databases: Run SQL setup scripts for PGvector in PostgreSQL. For Neo4j, note your login details.
4. Configure .env: Add your database URLs, LLM API keys, and set your embedding model in a .env file.
5. Ingest Documents: Place markdown files in the documents folder. Run python -m ingestion.ingest --clean to load your data into both the vector DB and the knowledge graph.
6. Review and Adjust Prompts: Edit prompts.py to fine-tune your agent’s reasoning and tool selection.
7. Start the API and CLI: Run python -m agent.api and python cli.py in separate terminals.
8. Test and Iterate: Ask questions of varying complexity to see how your agent chooses tools and synthesizes answers. Tweak prompts and data sources as needed.

Example 1:
You want to expand your system to include real-time stock data. You add a new “stock market tool,” update prompts.py so the agent can reason about when to use it, and add stock data ingestion to your pipeline.
Example 2:
You need to handle internal company documents with a unique format. You write a custom ingestion script, update your LLM for extraction, and adjust the knowledge graph schema for the new entities.

Tips:
- Keep your ingestion scripts modular so you can add new data sources easily.
- Store all configuration in environment variables for maximum flexibility.

Practical Applications and Advanced Use Cases

Once you’ve built your Agentic RAG system, the possibilities multiply:

• Company Intelligence Dashboards: Instantly answer questions about company initiatives, partnerships, and competitive landscapes.
• Research Synthesis: Summarize academic trends, map collaboration networks, and surface hidden connections in literature.
• Internal Knowledge Bases: Help employees find both raw facts and relational context for better decision-making.
• Custom AI Assistants: Deploy agents that can reason, explore, and explain their answers across multiple knowledge domains.

Example 1:
A sales rep asks, “Which companies in our database have partnerships with Microsoft and are investing in AI?” The agent queries both the vector DB and the knowledge graph, synthesizing a targeted list.
Example 2:
A product manager asks, “How does our current roadmap relate to our competitors’ recent initiatives?” The agent cross-references internal documents (vector DB) and competitor relationships (knowledge graph) to provide a synthesis.

Best Practices:
- Continually expand your knowledge graph schema to capture new relationship types.
- Monitor agent performance,review its tool choices and answers to identify reasoning gaps.
- Encourage users to ask follow-up questions; the agentic design supports deeper exploration.

Troubleshooting and Optimization

Building hybrid systems can get messy. Here’s how to keep things smooth:

• Slow Ingestion? Use smaller LLMs for the knowledge graph phase, batch your documents, and monitor compute costs.
• Agent Chooses Wrong Tool? Review and adjust your system prompt. Test with a range of query types,surface-level, relational, mixed.
• Database Errors? Make sure you’re running the latest setup scripts, and that your vector dimensions match your embedding model.
• Need to Add a New Data Source? Write a new ingestion module, update the knowledge schema, and document reasoning rules in prompts.py.

Example 1:
Your agent keeps using the vector database for relationship queries. You rewrite the system prompt to clarify when to switch to the knowledge graph.
Example 2:
You get “dimension mismatch” errors during ingestion. Double-check your embedding model’s output size and update the database schema.

Tips:
- Log every decision your agent makes during a query,this gives you insight into its reasoning process.
- Use version control for all config files, prompts, and ingestion scripts.

Expanding and Customizing Your Agentic RAG System

No system stays static. Here’s how to extend your Agentic RAG + Knowledge Graph agent:

• New Data Types: Want to add real-time feeds, PDFs, or custom APIs? Write new ingestion scripts and create schema extensions for the knowledge graph.
• Additional Reasoning Capabilities: Add “tools” for things like web search, summarization, or external APIs. Update prompts.py so the agent knows how to use them.
• Alternative LLMs and Embeddings: Test different providers for cost, speed, and quality,just update your environment variables.
• Multi-Agent Orchestration: For complex queries, chain multiple agents, each with their own specialties, and combine their outputs.

Example 1:
You integrate a financial news API. The agent now has a third tool,vector DB, knowledge graph, and financial news search. Prompts.py is updated so the agent can reason about which source to query based on the question context.
Example 2:
Your organization switches to a new preferred LLM for data privacy. You set up Ollama for local inference and update your ingestion and agent scripts.

Tips:
- Always update documentation and reasoning prompts when adding new tools.
- Test new integrations with real-world queries to validate agent decision-making.

Key Takeaways

Let’s recap the essential lessons from this course:

• Traditional RAG is limited by its rigidity, force-feeding context to LLMs without reasoning.
• Agentic RAG gives your AI agent the power to choose how it explores knowledge,flexibly selecting, combining, and synthesizing from multiple sources.
• Knowledge graphs unlock relational understanding, mapping entities and their connections.
• The real magic is in the fusion: agentic reasoning + knowledge graphs + vector search = answers with depth, context, and meaning.
• The technical stack,Pydantic AI, Graffiti/Neo4j, PGvector/PostgreSQL (Neon), FastAPI, Claude Code, and flexible LLMs,lets you build, test, and scale with confidence.
• System prompts are the agent’s mind,craft them carefully and iterate often.
• Automated tools like Claude Code accelerate development, reduce busywork, and let you focus on reasoning and results.
• Your system is never static,expand, refine, and tune as your needs evolve.

Conclusion: The Path Forward

The world doesn’t need more static answers,it needs systems that think, explore, and connect the dots. By mastering Agentic RAG and knowledge graphs, you’re not just building a better search engine,you’re creating an AI-powered research partner, analyst, and connector.
The free template provided is just the beginning. The real value comes from how you apply, adapt, and expand these ideas in your work. Whether you’re building internal knowledge bases, client-facing assistants, or next-generation research tools, the skills and frameworks you’ve learned here are your launchpad.
Don’t stop at answers. Build systems that find meaning, surface relationships, and empower others to ask better questions. That’s the future of AI,and now, it’s in your hands.

Frequently Asked Questions

This FAQ provides practical, detailed answers to the most common and important questions about Agentic RAG 2.0, blending agentic retrieval-augmented generation with knowledge graphs. It's structured to guide both newcomers and experienced professionals as they explore setup, technical implementation, reasoning, and real-world application of this hybrid AI approach. You'll find explanations, examples, and actionable insights to help you understand, build, and optimize your own Agentic RAG systems.

What is the core problem that Agentic RAG with Knowledge Graphs aims to solve, and how does it compare to traditional RAG?

Traditional RAG (Retrieval Augmented Generation) enhances LLM performance by supplying external context from a vector database, but it lacks flexibility.
It retrieves the most similar document chunks and feeds them directly to the LLM, without reasoning about which knowledge source or search method is best for the query. This limitation can lead to less accurate answers, especially for questions involving relationships or complex reasoning.
Agentic RAG, on the other hand, gives the AI agent the ability to reason about its approach. It can choose different tools,such as vector search for facts or knowledge graph queries for relationships,based on the nature of the question. For example, it might use vector search for "What are Google's AI initiatives?" but switch to the knowledge graph for "How are OpenAI and Microsoft related?" This agentic flexibility enables more precise, context-aware, and nuanced responses.

How do vector databases and knowledge graphs complement each other in this Agentic RAG system?

Vector databases and knowledge graphs each serve unique roles, enabling the agent to address a variety of queries more effectively.

• Vector Databases (e.g., PostgreSQL with PGVector) store and retrieve document chunks based on semantic similarity. They're ideal for direct, factual lookups,such as finding details about a specific company's projects,because they quickly locate relevant information using embeddings.
• Knowledge Graphs (e.g., Neo4j with Graffiti) represent data as entities and relationships. They shine in scenarios where understanding how entities connect is critical,such as mapping partnerships between companies or tracing influence across an industry.

What is "agentic reasoning" in the context of this RAG system, and how is it implemented?

Agentic reasoning means the AI agent can decide how to explore the knowledge base, selecting tools and strategies based on the query.
This is implemented through a system prompt supplied to the LLM, detailing its available tools (vector search, knowledge graph, etc.) and guidelines for when to use each. For example, the prompt might specify: "Use the knowledge graph when relationships between entities are involved; otherwise, use vector search."
This approach moves beyond fixed pipelines, allowing the agent to interpret user intent and tailor its method for each question. The agent's decision-making is transparent and can be adjusted by refining the system prompt, making it possible to align the agent's reasoning with business goals or data characteristics.

What are the key technical components and tools used to build this Agentic RAG agent?

The Agentic RAG agent relies on a combination of frameworks, databases, and AI models to function:

• AI Agent Framework: pydantic-AI orchestrates the agent's logic and tool usage.
• Vector Database: PostgreSQL with PGVector handles vector embeddings and similarity search.
• Knowledge Graph Engine: Neo4j represents relational data as nodes and edges.
• Knowledge Graph Library: Graffiti simplifies graph creation and management.
• API Development: FastAPI delivers a Python-based API for external access.
• LLM Providers: Compatible with OpenAI, Open Router, Ollama, Gemini, and others for both completions and embeddings.
• AI Coding Assistant: Claude Code (with MCP servers) helps automate everything from planning to database setup.

How is the knowledge base prepared and ingested into both the vector database and the knowledge graph?

Ingestion involves preparing documents and processing them for both vector and graph storage:

1. Markdown documents are placed in a designated folder.
2. For the vector database, documents are chunked and embedded (converted to vectors) using a model like text-embed-3-small, then stored in PostgreSQL.
3. Building the knowledge graph is more intensive: an LLM scans documents to extract entities and their relationships, then constructs the graph in Neo4j using Graffiti.

What are the different ways a user can interact with the Agentic RAG system, and how does the agent demonstrate its reasoning in these interactions?

The primary interaction method is a command-line interface (CLI) linked to the agent's API.
When you ask a question, the agent responds and specifies which tool(s) it used,for example, "Used vector search" for a factual question, or "Consulted the knowledge graph" for a relational query. For complex questions, it may combine both methods.
This explicit feedback makes the agent's reasoning process transparent, allowing users to understand and trust how answers are generated. It's particularly useful for debugging, demonstration, or refining the agent's system prompt.

How does Claude Code, the AI coding assistant, facilitate the development of such a complex agentic system?

Claude Code acts as an autonomous AI co-developer, streamlining everything from planning to database management.

• MCP servers let it access external tools (like Neon for PostgreSQL) and relevant documentation.
• Planning mode encourages thorough project design before coding starts, resulting in planning.md and task.md files.
• Autonomous execution means Claude Code can generate, test, and iterate on the codebase,requiring only approvals from the developer.
• Reference folders (examples) help Claude Code align with best practices.

What are the practical steps to set up and run this Agentic RAG with Knowledge Graph agent locally?

To run the agent locally, follow these steps:

1. Install Python, PostgreSQL (with PGVector, ideally via Neon), and Neo4j (either through the package or Desktop).
2. Clone the repository, set up a Python virtual environment, and install dependencies.
3. Configure PostgreSQL with the provided SQL script, adjusting vector dimensions if needed.
4. Start Neo4j and note its connection details.
5. Copy .env.example to .env, then fill in all database and LLM provider credentials.
6. Add your markdown documents to the documents folder.
7. Run the ingestion script with the "-d clean" flag to process documents and build both the vector and graph stores.
8. Optionally, adjust the agent's system prompt in agent/prompts.py to fine-tune reasoning behavior.
9. Start the agent API server, then launch the CLI to interact with the agent.

What is the primary limitation of "vanilla RAG" that Agentic RAG aims to address?

Vanilla RAG is inflexible,it always retrieves and feeds the most similar document chunks to the LLM, regardless of query complexity.
It can't refine its search or reason about which knowledge source would be best. Agentic RAG overcomes this by allowing the agent to select the most relevant retrieval strategy, improving accuracy for a wider range of queries.

How do vector databases and knowledge graphs differ in their representation of information, and when might you prefer one over the other?

Vector databases store text as numerical embeddings for similarity searches; knowledge graphs represent entities and their relationships explicitly.
You'd use a vector database for straightforward lookups (e.g., "Tell me about Amazon's AI projects") and a knowledge graph when relationships matter (e.g., "Which companies are Amazon partnering with in AI?").

Name two specific tools or libraries used for building the knowledge graph component of the Agentic RAG system.

Graffiti is the Python library used to construct and manage the knowledge graph, while Neo4j serves as the underlying graph database engine.

Explain the role of the prompts.py file in configuring the Agentic RAG agent's behaviour.

The prompts.py file defines the primary system prompt that guides the agent's reasoning process.
It tells the agent when to use the vector database, the knowledge graph, or a combination,essentially shaping how the AI interprets and responds to user queries.

What is the purpose of the d-clean flag when running the ingestion script?

The d-clean flag wipes and recreates the knowledge graph and vector database tables before ingestion begins.
This ensures you're starting with a clean slate,crucial for testing, demos, or when your underlying documents have changed.

Describe how Claude Code assists in the database management aspect of building the Agentic RAG agent, specifically mentioning Neon.

Claude Code integrates with MCP servers like Neon's, allowing it to automate PostgreSQL database setup, schema validation, and SQL query execution.
This reduces manual intervention and ensures your vector database is configured quickly and correctly.

What are the three key markdown files that guide the AI coding process with Claude Code, and what is the primary function of each?

claw.md holds global rules and instructions for the assistant.
planning.md describes the project architecture, tech stack, and design at a high level.
task.md lists detailed tasks that Claude Code will execute during the build process.

How does Claude Code's "plan mode" facilitate the initial stages of project development?

Plan mode prompts the developer to brainstorm ideas and for Claude Code to ask clarifying questions before any code is written.
This leads to a comprehensive planning.md and task.md, ensuring the project starts with clear direction and priorities.

Why is building a knowledge graph described as "computationally expensive" compared to inserting data into a vector database?

Constructing a knowledge graph requires the LLM to extract entities and relationships from documents, involving many embedding and chat completion calls.
This process is more complex and takes much longer (minutes versus seconds) than simply chunking and embedding text for a vector database.

What is the significance of being able to use different LLM providers for the main agent and the ingestion process?

This flexibility lets you optimize for cost, quality, and speed.
For example, you might use a top-tier model for the main agent's responses and a more affordable or specialized model for the resource-intensive ingestion process.

What are the pros and cons of giving the agent explicit instructions in its system prompt versus allowing implicit reasoning?

Explicit instructions make the agent's reasoning predictable and easier to debug, which is great for demos or controlled environments.
However, allowing more implicit reasoning in the prompt can lead to a more adaptable and intelligent agent,at the cost of less transparency and possibly unexpected behavior. The ideal balance depends on your use case and user needs.

What are some real-world use cases for Agentic RAG with Knowledge Graphs in a business context?

This hybrid approach excels in scenarios where both factual lookups and relational reasoning are important.
Examples include:

• Competitive intelligence (mapping partnerships and rivalries)
• Enterprise Q&A over internal documents and organizational charts
• Customer support systems that need to resolve requests by combining product details (vector search) with support escalation paths (knowledge graph)
• Market research on investment flows and company networks

How can I customize the ingestion process for my own data sources and document formats?

You can adapt the ingestion script to handle various document formats by extending the chunking, embedding, and entity extraction steps.
For example, you might add a pre-processing step for PDFs or emails, or tweak the LLM prompts to better match your domain-specific language. The modularity of the provided scripts makes this straightforward.

What should I do if the knowledge graph ingestion process is taking too long or failing?

Long ingestion times usually stem from large documents or limited LLM throughput.
Try breaking documents into smaller files, batch processing, or switching to a faster embedding/LLM provider for ingestion. If failures occur, check for malformed documents, API rate limits, or memory constraints in your Neo4j instance.

What are common challenges when integrating both vector databases and knowledge graphs?

Synchronization is a frequent challenge,ensuring both stores reflect the latest data.
Other issues include performance bottlenecks (especially with large graphs), increased complexity in debugging, and the need to carefully design system prompts so the agent picks the right tool for each query.

What are key security considerations when deploying an Agentic RAG system with business data?

Protect database credentials and API keys using secure environment variables or vaults.
Apply proper access controls to both the vector database and knowledge graph, and consider encrypting sensitive embeddings or graph data. For cloud deployments, use managed services with built-in security features.

How can I optimize the system prompt to improve the agent's reasoning and answer quality?

Iteratively refine the prompt based on real user queries and feedback.
Include clear guidelines for tool selection, edge cases, and preferred answer formats. Use test cases to validate changes, and avoid overly rigid instructions that could stifle the agent's flexibility.

Can I use multiple LLMs in a single Agentic RAG workflow?

Yes, you can configure separate LLMs for different stages,one for ingestion (entity extraction, embeddings) and another for answering queries.
This lets you balance cost, speed, and quality, tailoring the system to your organization's needs and available resources.

What steps should I take to scale an Agentic RAG system for production use?

Focus on containerizing your services, using managed databases (like Neon and Aura for Neo4j), and implementing robust monitoring and logging.
Automate ingestion pipelines, add caching for frequent queries, and consider horizontal scaling for the API and vector search components.

How can I inspect or visualize the knowledge graph built by the system?

Neo4j offers a user-friendly browser for exploring and querying your graph visually.
You can run Cypher queries to highlight specific relationships or use third-party visualization libraries to embed graph views in dashboards or custom interfaces.

How do I maintain and update the knowledge base as new data arrives?

Automate regular ingestion of new documents, and use the "clean" flag sparingly for full rebuilds.
For incremental updates, design your ingestion pipeline to detect and process only changed or new files,reducing downtime and computational load.

What are some tips for optimizing query performance in Agentic RAG systems?

For vector search, use appropriate chunk sizes and efficient embedding models.
In the knowledge graph, index high-traffic relationships and prune unnecessary nodes. Monitor database load and adjust connection pool sizes for sustained responsiveness.

What are the current limitations of Agentic RAG systems integrating knowledge graphs?

Major limitations include computational overhead during graph building, dependency on accurate entity extraction, and the need for careful prompt engineering.
Real-time updates can be challenging, and the complexity of orchestrating multiple knowledge sources may introduce new failure points.

Can Agentic RAG systems support multi-tenant or multi-user scenarios?

Yes, but you need to partition your vector and graph databases (or manage access at the application layer).
Use separate schemas or databases per tenant and implement authentication and authorization in the API layer.

How should I approach integrating a new data source, such as real-time feeds or custom document formats?

Start by extending the ingestion pipeline to handle the new data type (e.g., setting up a parser or connector).
Update the chunking/embedding process for the vector store, and adjust the entity/relationship extraction logic for the knowledge graph. Modify the agent's system prompt to recognize when and how to use the new data source.

How can I manage costs when running LLM-powered ingestion and queries at scale?

Use lightweight or open-source embedding models for ingestion, and reserve premium LLMs for complex queries.
Batch process documents, monitor API usage, and consider hybrid deployments (local + cloud) to balance cost and performance.

How does Agentic RAG differ from standard knowledge graph QA or traditional search systems?

Agentic RAG combines the strengths of both vector-based retrieval and relational reasoning, letting the agent dynamically select the best tool for each query.
Standard search retrieves based on keywords, while knowledge graph QA focuses only on relationships. Agentic RAG unifies both, adapting to the complexity of the user's questions.

How can I monitor and debug the agent's reasoning and retrieval strategies?

Enable verbose logging in the CLI and API, and review which tools the agent selects for each query.
For deeper insight, log the actual retrieval results from both the vector and knowledge graph stores, and compare agent output to expected answers using a test harness.

What are promising future directions for Agentic RAG and agentic knowledge systems?

Key areas include automating prompt optimization, improving real-time data integration, and developing agents that can dynamically learn new retrieval tools.
Agentic approaches may soon support multi-hop reasoning across hybrid stores, adaptive learning based on user feedback, and seamless integration with enterprise knowledge lakes.