An Implementation of IWE’s Context Bridge as an AI-Powered Knowledge Graph with Agentic RAG, OpenAI Function Calling, and Graph Traversal

import subprocess, sys


def _install(pkg):
   subprocess.check_call([sys.executable, "-m", "pip", "install", "-q", pkg])


_install("openai")
_install("graphviz")


import re, json, textwrap, os, getpass
from collections import defaultdict
from dataclasses import dataclass, area
from typing import Optional
from datetime import datetime


strive:
   from google.colab import userdata
   OPENAI_API_KEY = userdata.get("OPENAI_API_KEY")
   if not OPENAI_API_KEY:
       elevate WorthError
   print("  Loaded OPENAI_API_KEY from Colab secrets and techniques.")
besides Exception:
   OPENAI_API_KEY = getpass.getpass(" Enter your OpenAI API key: ")
   print("  API key acquired.")


os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY


from openai import OpenAI
consumer = OpenAI(api_key=OPENAI_API_KEY)


print("n" + "=" * 72)
print("  IWE Advanced Tutorial — Knowledge Graph + AI Agents")
print("=" * 72)


@dataclass
class Section:
   degree: int
   title: str
   content material: str
   youngsters: listing = area(default_factory=listing)


@dataclass
class Document:
   key: str
   title: str
   raw_content: str
   sections: listing = area(default_factory=listing)
   outgoing_links: listing = area(default_factory=listing)
   tags: listing = area(default_factory=listing)
   created: str = ""
   modified: str = ""




class KnowledgeGraph:


   def __init__(self):
       self.paperwork: dict[str, Document] = {}
       self.backlinks: dict[str, set] = defaultdict(set)


   _WIKI_LINK = re.compile(r"[[([^]|]+)(?:|([^]]+))?]]")
   _MD_LINK   = re.compile(r"[([^]]+)](([^)]+))")
   _HEADER    = re.compile(r"^(#{1,6})s+(.+)", re.MULTILINE)
   _TAG       = re.compile(r"#([a-zA-Z][w/-]*)")


   def _extract_links(self, textual content: str) -> listing[str]:
       hyperlinks = []
       for match in self._WIKI_LINK.finditer(textual content):
           hyperlinks.append(match.group(1).strip())
       for match in self._MD_LINK.finditer(textual content):
           goal = match.group(2).strip()
           if not goal.startswith("http"):
               goal = goal.exchange(".md", "")
               hyperlinks.append(goal)
       return hyperlinks


   def _parse_sections(self, textual content: str) -> listing[Section]:
       sections = []
       components = self._HEADER.break up(textual content)
       i = 1
       whereas i < len(components) - 1:
           degree = len(components[i])
           title = components[i + 1].strip()
           physique = components[i + 2] if i + 2 < len(components) else ""
           sections.append(Section(degree=degree, title=title, content material=physique.strip()))
           i += 3
       return sections


   def _extract_tags(self, textual content: str) -> listing[str]:
       tags = set()
       for line in textual content.break up("n"):
           if line.strip().startswith("#") and " " in line.strip():
               stripped = re.sub(r"^#{1,6}s+.*", "", line)
               for m in self._TAG.finditer(stripped):
                   tags.add(m.group(1))
           else:
               for m in self._TAG.finditer(line):
                   tags.add(m.group(1))
       return sorted(tags)


   def add_document(self, key: str, content material: str) -> Document:
       sections = self._parse_sections(content material)
       title = sections[0].title if sections else key
       hyperlinks = self._extract_links(content material)
       tags = self._extract_tags(content material)
       now = datetime.now().strftime("%Y-%m-%d %H:%M")


       doc = Document(
           key=key, title=title, raw_content=content material,
           sections=sections, outgoing_links=hyperlinks, tags=tags,
           created=now, modified=now,
       )
       self.paperwork[key] = doc


       for goal in hyperlinks:
           self.backlinks[target].add(key)


       return doc


   def get(self, key: str) -> Optional[Document]:
       return self.paperwork.get(key)


   def discover(self, question: str, roots_only: bool = False, restrict: int = 10) -> listing[str]:
       q = question.decrease()
       scored = []
       for key, doc in self.paperwork.objects():
           rating = 0
           if q in doc.title.decrease():
               rating += 10
           if q in doc.raw_content.decrease():
               rating += doc.raw_content.decrease().rely(q)
           if q in key.decrease():
               rating += 5
           for tag in doc.tags:
               if q in tag.decrease():
                   rating += 3
           if rating > 0:
               scored.append((key, rating))
       scored.kind(key=lambda x: -x[1])


       outcomes = [k for k, _ in scored[:limit]]
       if roots_only:
           outcomes = [k for k in results if not self.backlinks.get(k)]
       return outcomes


   def retrieve(self, key: str, depth: int = 1, context: int = 1,
                exclude: set = None) -> str:
       exclude = exclude or set()
       components = []


       if context > 0:
           parents_of = listing(self.backlinks.get(key, set()) - exclude)
           for p in parents_of[:context]:
               pdoc = self.get(p)
               if pdoc:
                   components.append(f"[CONTEXT: {pdoc.title}]n{pdoc.raw_content[:300]}...n")
                   exclude.add(p)


       doc = self.get(key)
       if not doc:
           return f" Document '{key}' not discovered."
       components.append(doc.raw_content)
       exclude.add(key)


       if depth > 0:
           for hyperlink in doc.outgoing_links:
               if hyperlink not in exclude:
                   little one = self.get(hyperlink)
                   if little one:
                       components.append(f"n---n[LINKED: {child.title}]n")
                       components.append(
                           self.retrieve(hyperlink, depth=depth - 1,
                                         context=0, exclude=exclude)
                       )
       return "n".be part of(components)


   def tree(self, key: str, indent: int = 0, _visited: set = None) -> str:
       _visited = _visited if _visited will not be None else set()
       doc = self.get(key)
       if not doc:
           return ""
       prefix = "  " * indent + ("└─ " if indent else "")
       if key in _visited:
           return f"{prefix}{doc.title} ({key})  (round ref)"
       _visited.add(key)
       traces = [f"{prefix}{doc.title} ({key})"]
       for hyperlink in doc.outgoing_links:
           if self.get(hyperlink):
               traces.append(self.tree(hyperlink, indent + 1, _visited))
       return "n".be part of(traces)


   def squash(self, key: str, visited: set = None) -> str:
       visited = visited or set()
       doc = self.get(key)
       if not doc or key in visited:
           return ""
       visited.add(key)
       components = [doc.raw_content]
       for hyperlink in doc.outgoing_links:
           child_content = self.squash(hyperlink, visited)
           if child_content:
               components.append(f"n{'─' * 40}n")
               components.append(child_content)
       return "n".be part of(components)


   def stats(self) -> dict:
       total_words = sum(len(d.raw_content.break up()) for d in self.paperwork.values())
       total_links = sum(len(d.outgoing_links) for d in self.paperwork.values())
       orphans = [k for k in self.documents if not self.backlinks.get(k)
                  and not self.documents[k].outgoing_links]
       all_tags = set()
       for d in self.paperwork.values():
           all_tags.replace(d.tags)
       return {
           "total_documents": len(self.paperwork),
           "total_words": total_words,
           "total_links": total_links,
           "unique_tags": len(all_tags),
           "tags": sorted(all_tags),
           "orphan_notes": orphans,
           "avg_words_per_doc": total_words // max(len(self.paperwork), 1),
       }


   def export_dot(self, highlight_key: str = None) -> str:
       traces = ['digraph KnowledgeGraph {',
                '  rankdir=LR;',
                '  node [shape=box, style="rounded,filled", fillcolor="#f0f4ff", '
                'fontname="Helvetica", fontsize=10];',
                '  edge [color="#666666", arrowsize=0.7];']
       for key, doc in self.paperwork.objects():
           label = doc.title[:30]
           shade = '#ffe4b5' if highlight_key == key else '#f0f4ff'
           traces.append(f'  "{key}" [label="{label}", fillcolor="{color}"];')
       for key, doc in self.paperwork.objects():
           for hyperlink in doc.outgoing_links:
               if hyperlink in self.paperwork:
                   traces.append(f'  "{key}" -> "{hyperlink}";')
       traces.append("}")
       return "n".be part of(traces)




print("n  Section 1 full — KnowledgeGraph class outlined.n")

kg = KnowledgeGraph()


kg.add_document("project-index", """# Web App Project


This is the **Map of Content** for our net software venture.


## Architecture


- [Authentication System](authentication)
- [Database Design](database-design)
- [API Design](api-design)


## Development


- [Frontend Stack](frontend-stack)
- [Deployment Pipeline](deployment)


## Research


- [[caching-strategies]]
- [[performance-notes]]
""")


kg.add_document("authentication", """# Authentication System


Our app makes use of **JWT-based authentication** with refresh tokens.


## Flow


1. User submits credentials to `/api/auth/login`
2. Server validates in opposition to [Database Design](database-design) person desk
3. Returns short-lived entry token (15 min) + refresh token (7 days)
4. Client shops refresh token in HTTP-only cookie


## Security Considerations


- Passwords hashed with bcrypt (value issue 12)
- Rate limiting on login endpoint: 5 makes an attempt / minute
- Refresh token rotation on every use
- See [[caching-strategies]] for session caching


#safety #jwt #auth
""")


kg.add_document("database-design", """# Database Design


We use **PostgreSQL 16** with the next core tables.


## Users Table


```sql
CREATE TABLE customers (
   id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
   electronic mail       VARCHAR(255) UNIQUE NOT NULL,
   password    VARCHAR(255) NOT NULL,
   created_at  TIMESTAMPTZ DEFAULT NOW()
);
```


## Sessions Table


```sql
CREATE TABLE classes (
   id          UUID PRIMARY KEY,
   user_id     UUID REFERENCES customers(id),
   token_hash  VARCHAR(255) NOT NULL,
   expires_at  TIMESTAMPTZ NOT NULL
);
```


## Indexing Strategy


- B-tree on `customers.electronic mail` for login lookups
- B-tree on `classes.token_hash` for token validation
- See [[performance-notes]] for question optimization


#database #postgresql #schema
""")


kg.add_document("api-design", """# API Design


RESTful API following OpenAPI 3.0 specification.


## Endpoints


| Method | Path | Description |
|--------|------|-------------|
| POST | /api/auth/login | Authenticate person |
| POST | /api/auth/refresh | Refresh entry token |
| GET | /api/customers/me | Get present person profile |
| PUT | /api/customers/me | Update profile |


## Error Handling


All errors return JSON with `{ "error": "code", "message": "..." }`.


Authentication endpoints documented in [Authentication System](authentication).
Data fashions align with [Database Design](database-design).


#api #relaxation #openapi
""")


kg.add_document("frontend-stack", """# Frontend Stack


## Technology Choices


- **Framework**: React 19 with Server Components
- **Styling**: Tailwind CSS v4
- **State Management**: Zustand for consumer state
- **Data Fetching**: TanStack Query v5


## Auth Integration


The frontend consumes the [API Design](api-design) endpoints.
Access tokens are saved in reminiscence (not localStorage) for safety.
Refresh dealt with transparently by way of Axios interceptors.


#frontend #react #tailwind
""")


kg.add_document("deployment", """# Deployment Pipeline


## Infrastructure


- **Container Runtime**: Docker with multi-stage builds
- **Orchestration**: Kubernetes on GKE
- **CI/CD**: GitHub Actions → Google Artifact Registry → GKE


## Pipeline Stages


1. Lint & type-check
2. Unit assessments (Jest + pytest)
3. Build Docker photos
4. Push to Artifact Registry
5. Deploy to staging (auto)
6. Deploy to manufacturing (handbook approval)


## Monitoring


- Prometheus + Grafana for metrics
- Structured logging with correlation IDs
- See [[performance-notes]] for SLOs


#devops #kubernetes #cicd
""")


kg.add_document("caching-strategies", """# Caching Strategies


## Application-Level Caching


- **Redis** for session storage and price limiting
- Cache-aside sample for regularly accessed person profiles
- TTL: 5 minutes for profiles, quarter-hour for config


## HTTP Caching


- `Cache-Control: non-public, max-age=0` for authenticated endpoints
- `Cache-Control: public, max-age=3600` for static belongings
- ETag assist for conditional requests


## Cache Invalidation


- Event-driven invalidation by way of pub/sub
- Versioned cache keys: `person:{id}:v{model}`


Related: [Authentication System](authentication) makes use of Redis for refresh tokens.


#caching #redis #efficiency
""")


kg.add_document("performance-notes", """# Performance Notes


## Database Query Optimization


- Use `EXPLAIN ANALYZE` earlier than deploying new queries
- Connection pooling with PgBouncer (max 50 connections)
- Avoid N+1 queries — use JOINs or DataLoader sample


## SLO Targets


| Metric | Target | Current |
|--------|--------|---------|
| p99 latency | < 200ms | 180ms |
| Availability | 99.9% | 99.95% |
| Error price | < 0.1% | 0.05% |


## Load Testing


- k6 scripts in `/assessments/load/`
- Baseline: 1000 RPS sustained
- Spike: 5000 RPS for 60 seconds


Related to [Database Design](database-design) indexing and [[caching-strategies]].


#efficiency #slo #monitoring
""")


print("  Section 2 full — 8 paperwork loaded into data graph.n")


print("─" * 72)
print("  3A · iwe discover — Search the Knowledge Graph")
print("─" * 72)


outcomes = kg.discover("authentication")
print(f"n discover('authentication'): {outcomes}")


outcomes = kg.discover("efficiency")
print(f" discover('efficiency'):    {outcomes}")


outcomes = kg.discover("cache", roots_only=True)
print(f" discover('cache', roots_only=True): {outcomes}")


print("n" + "─" * 72)
print("  3B · iwe tree — Document Hierarchy")
print("─" * 72)
print()
print(kg.tree("project-index"))


print("n" + "─" * 72)
print("  3C · iwe stats — Knowledge Base Statistics")
print("─" * 72)


stats = kg.stats()
for okay, v in stats.objects():
   print(f"  {okay:>25s}: {v}")


print("n" + "─" * 72)
print("  3D · iwe retrieve — Context-Aware Retrieval")
print("─" * 72)


print("n Retrieving 'authentication' with depth=1, context=1:n")
retrieved = kg.retrieve("authentication", depth=1, context=1)
print(retrieved[:800] + "n... (truncated)")


print("n" + "─" * 72)
print("  3E · iwe squash — Combine Documents")
print("─" * 72)


squashed = kg.squash("project-index")
print(f"n Squashed 'project-index': {len(squashed)} characters, "
     f"{len(squashed.break up())} phrases")


print("n" + "─" * 72)
print("  3F · iwe export dot — Graph Visualization")
print("─" * 72)


dot_output = kg.export_dot(highlight_key="project-index")
print(f"n DOT output ({len(dot_output)} chars):n")
print(dot_output[:500] + "n...")


strive:
   import graphviz
   src = graphviz.Source(dot_output)
   src.render("knowledge_graph", format="png", cleanup=True)
   print("n  Graph rendered to 'knowledge_graph.png'")


   strive:
       from IPython.show import Image, show
       show(Image("knowledge_graph.png"))
   besides ImportError:
       print("   (Run in Colab/Jupyter to see the picture inline)")
besides Exception as e:
   print(f"    Graphviz rendering skipped: {e}")


print("n  Section 3 full — all graph operations demonstrated.n")

print("─" * 72)
print("  4 · AI-Powered Document Transforms")
print("─" * 72)




def ai_transform(textual content: str, motion: str, context: str = "",
                mannequin: str = "gpt-4o-mini") -> str:
   prompts = {
       "rewrite": (
           "Rewrite the next textual content to enhance readability and readability. "
           "Keep the markdown formatting. Return ONLY the rewritten textual content."
       ),
       "summarize": (
           "Summarize the next textual content in 2-3 concise bullet factors. "
           "Focus on the important thing selections and technical selections."
       ),
       "develop": (
           "Expand the next textual content with extra technical element and examples. "
           "Keep the identical construction and add depth."
       ),
       "extract_todos": (
           "Extract all actionable objects from this textual content and format them as "
           "a markdown todo listing. If there aren't any actionable objects, recommend "
           "related subsequent steps primarily based on the content material."
       ),
       "generate_links": (
           "Analyze the next notice and recommend associated matters that ought to "
           "be linked. Format as a markdown listing of wiki-links: [[topic-name]]. "
           "Only recommend matters which can be genuinely associated."
       ),
   }


   system_msg = prompts.get(motion, prompts["rewrite"])
   if context:
       system_msg += f"nnDocument context:n{context[:500]}"


   messages = [
       {"role": "system", "content": system_msg},
       {"role": "user", "content": text},
   ]


   response = consumer.chat.completions.create(
       mannequin=mannequin, messages=messages, temperature=0.3, max_tokens=1000,
   )
   return response.selections[0].message.content material.strip()




auth_doc = kg.get("authentication")


print("n Transform: SUMMARIZE — Authentication Systemn")
abstract = ai_transform(auth_doc.raw_content, "summarize")
print(abstract)


print("nn Transform: GENERATE_LINKS — Authentication Systemn")
hyperlinks = ai_transform(auth_doc.raw_content, "generate_links")
print(hyperlinks)


print("nn Transform: EXTRACT_TODOS — Performance Notesn")
perf_doc = kg.get("performance-notes")
todos = ai_transform(perf_doc.raw_content, "extract_todos")
print(todos)


print("n  Section 4 full — AI transforms demonstrated.n")

print("─" * 72)
print("  5 · Agentic RAG — AI Navigates Your Knowledge Graph")
print("─" * 72)




AGENT_TOOLS = [
   {
       "type": "function",
       "function": {
           "name": "iwe_find",
           "description": "Search the knowledge graph for documents matching a query. Returns a list of document keys.",
           "parameters": {
               "type": "object",
               "properties": {
                   "query": {"type": "string", "description": "Search query"},
                   "roots_only": {"type": "boolean", "description": "Only return root/MOC documents", "default": False},
               },
               "required": ["query"],
           },
       },
   },
   {
       "kind": "operate",
       "operate": {
           "identify": "iwe_retrieve",
           "description": "Retrieve a doc's content material with linked context. Use depth>0 to comply with outgoing hyperlinks, context>0 to incorporate mum or dad paperwork.",
           "parameters": {
               "kind": "object",
               "properties": {
                   "key": {"kind": "string", "description": "Document key to retrieve"},
                   "depth": {"kind": "integer", "description": "How many ranges of little one hyperlinks to comply with (0-2)", "default": 1},
                   "context": {"kind": "integer", "description": "How many ranges of mum or dad context (0-1)", "default": 0},
               },
               "required": ["key"],
           },
       },
   },
   {
       "kind": "operate",
       "operate": {
           "identify": "iwe_tree",
           "description": "Show the doc hierarchy ranging from a given key.",
           "parameters": {
               "kind": "object",
               "properties": {
                   "key": {"kind": "string", "description": "Root doc key"},
               },
               "required": ["key"],
           },
       },
   },
   {
       "kind": "operate",
       "operate": {
           "identify": "iwe_stats",
           "description": "Get statistics about the whole data base.",
           "parameters": {"kind": "object", "properties": {}},
       },
   },
]




def execute_tool(identify: str, args: dict) -> str:
   if identify == "iwe_find":
       outcomes = kg.discover(args["query"], roots_only=args.get("roots_only", False))
       return json.dumps({"outcomes": outcomes})
   elif identify == "iwe_retrieve":
       content material = kg.retrieve(
           args["key"],
           depth=args.get("depth", 1),
           context=args.get("context", 0),
       )
       return content material[:3000]
   elif identify == "iwe_tree":
       return kg.tree(args["key"])
   elif identify == "iwe_stats":
       return json.dumps(kg.stats(), indent=2)
   return "Unknown instrument"




def run_agent(query: str, max_turns: int = 6, mannequin: str = "gpt-4o-mini") -> str:
   system_prompt = textwrap.dedent("""
       You are an AI assistant with entry to a private data graph (IWE).
       Use the offered instruments to navigate the graph and reply questions.


       Workflow:
       1. Use iwe_find to find related paperwork
       2. Use iwe_retrieve to learn content material (set depth=1 to comply with hyperlinks)
       3. Follow relationships to construct complete understanding
       4. Synthesize info from a number of paperwork


       Be particular and cite which paperwork you discovered info in.
       If you can not discover sufficient info, say so clearly.
   """)


   messages = [
       {"role": "system", "content": system_prompt},
       {"role": "user", "content": question},
   ]


   for flip in vary(max_turns):
       response = consumer.chat.completions.create(
           mannequin=mannequin, messages=messages, instruments=AGENT_TOOLS,
           tool_choice="auto",
       )
       msg = response.selections[0].message


       if msg.tool_calls:
           messages.append(msg)
           for tc in msg.tool_calls:
               fn_name = tc.operate.identify
               fn_args = json.hundreds(tc.operate.arguments)
               print(f"    Agent calls: {fn_name}({fn_args})")
               end result = execute_tool(fn_name, fn_args)
               messages.append({
                   "function": "instrument",
                   "tool_call_id": tc.id,
                   "content material": end result,
               })
       else:
           return msg.content material


   return "Agent reached most turns with out finishing."




questions = [
   "How does our authentication system work, and what database tables does it depend on?",
   "What is our deployment pipeline, and what are the performance SLO targets?",
   "Give me a high-level overview of the entire project architecture.",
]


for i, q in enumerate(questions, 1):
   print(f"n{'═' * 72}")
   print(f"  Question {i}: {q}")
   print(f"{'═' * 72}n")
   reply = run_agent(q)
   print(f"n Agent Answer:n{reply}n")


print("n  Section 5 full — Agentic RAG demonstrated.n")

print("─" * 72)
print("  6 · AI-Powered Knowledge Graph Maintenance")
print("─" * 72)




def analyze_knowledge_gaps(mannequin: str = "gpt-4o-mini") -> str:
   stats_info = json.dumps(kg.stats(), indent=2)
   titles = [f"- {d.title} ({k}): links to {d.outgoing_links}"
             for k, d in kg.documents.items()]
   graph_overview = "n".be part of(titles)


   response = consumer.chat.completions.create(
       mannequin=mannequin,
       messages=[
           {"role": "system", "content": (
               "You are a knowledge management consultant. Analyze this "
               "knowledge graph and identify: (1) missing topics that should "
               "exist, (2) documents that should be linked but aren't, "
               "(3) areas that need more detail. Be specific and actionable."
           )},
           {"role": "user", "content": (
               f"Knowledge base stats:n{stats_info}nn"
               f"Document structure:n{graph_overview}"
           )},
       ],
       temperature=0.4, max_tokens=1000,
   )
   return response.selections[0].message.content material.strip()




def generate_new_note(subject: str, related_keys: listing[str],
                     mannequin: str = "gpt-4o-mini") -> str:
   context_parts = []
   for key in related_keys[:3]:
       doc = kg.get(key)
       if doc:
           context_parts.append(f"## {doc.title}n{doc.raw_content[:400]}")
   context = "nn".be part of(context_parts)


   response = consumer.chat.completions.create(
       mannequin=mannequin,
       messages=[
           {"role": "system", "content": (
               "You are a technical writer. Generate a new markdown note "
               "about the given topic. Use wiki-links [[like-this]] to "
               "reference associated present paperwork. Include related "
               "headers, code examples the place applicable, and hashtag tags."
           )},
           {"function": "person", "content material": (
               f"Topic: {subject}nn"
               f"Related present notes for context:n{context}nn"
               f"Available paperwork to hyperlink to: {listing(kg.paperwork.keys())}"
           )},
       ],
       temperature=0.5, max_tokens=1200,
   )
   return response.selections[0].message.content material.strip()




print("n Analyzing data gaps...n")
gaps = analyze_knowledge_gaps()
print(gaps)


print("nn Generating a brand new notice: 'Error Handling Strategy'...n")
new_note = generate_new_note(
   "Error Handling Strategy",
   related_keys=["api-design", "authentication", "frontend-stack"],
)
print(new_note[:1000] + "n... (truncated)")


kg.add_document("error-handling", new_note)
print(f"n  Added 'error-handling' to data graph. "
     f"Total paperwork: {len(kg.paperwork)}")


dot_output = kg.export_dot(highlight_key="error-handling")
strive:
   import graphviz
   src = graphviz.Source(dot_output)
   src.render("knowledge_graph_v2", format="png", cleanup=True)
   print("  Updated graph rendered to 'knowledge_graph_v2.png'")
   strive:
       from IPython.show import Image, show
       show(Image("knowledge_graph_v2.png"))
   besides ImportError:
       cross
besides Exception as e:
   print(f"    Graphviz rendering skipped: {e}")


print("n  Section 6 full — AI-powered upkeep demonstrated.n")


print("─" * 72)
print("  7 · Multi-Hop Reasoning Across the Knowledge Graph")
print("─" * 72)


complex_question = (
   "If we enhance our site visitors from 1000 RPS to 5000 RPS sustained, "
   "what modifications could be wanted throughout the whole stack — from database "
   "connection pooling, to caching, to authentication token dealing with, "
   "to deployment infrastructure?"
)


print(f"n Complex multi-hop query:n   {complex_question}n")
reply = run_agent(complex_question, max_turns=8)
print(f"n Agent Answer:n{reply}")


print("nn" + "=" * 72)
print("    TUTORIAL COMPLETE")
print("=" * 72)
print("""
You've explored all of the core ideas of IWE:


 1. Knowledge Graph    — Documents as nodes, hyperlinks as edges
 2. Markdown Parsing   — Wiki-links, headers, tags
 3. Maps of Content    — Hierarchical organisation (MOC)
 4. Graph Operations   — discover, retrieve, tree, squash, stats, export
 5. AI Transforms      — Rewrite, summarize, develop, extract todos
 6. Agentic Retrieval  — AI agent navigating your data graph
 7. Graph Maintenance  — AI-powered hole evaluation and notice technology
 8. Multi-Hop Reasoning — Cross-document synthesis


To use IWE for actual (with your editor):
 → https://github.com/iwe-org/iwe
 → https://iwe.md/quick-start


IWE helps VS Code, Neovim, Zed, and Helix by way of LSP.
""")