clean initial commit

backend/evaluate.py

@@ -0,0 +1,389 @@
+import sys
+import time
+import json
+import os
+
+sys.path.insert(0, ".")
+
+from backend.rag import query_rag
+from backend.llm_only import query_llm_only
+from backend.graphrag import (
+    query_graphrag,
+    build_graph
+)
+
+from bert_score import (
+    score as bert_score
+)
+
+from groq import Groq
+from dotenv import load_dotenv
+
+load_dotenv()
+
+judge = Groq(
+    api_key=os.getenv(
+        "GROQ_API_KEY"
+    )
+)
+
+
+def llm_judge(
+    question,
+    ground_truth,
+    answer
+) -> bool:
+
+    prompt = f"""
+You are a lenient evaluation judge for financial questions.
+
+Question:
+{question}
+
+Ground Truth:
+{ground_truth}
+
+Answer:
+{answer}
+
+Does the Answer convey the same meaning or key facts as the Ground Truth, even if worded differently?
+
+Reply only YES or NO.
+"""
+
+    r = (
+        judge.chat
+        .completions.create(
+            model=
+            "llama-3.1-8b-instant",
+            messages=[{
+                "role": "user",
+                "content": prompt
+            }],
+            max_tokens=5
+        )
+    )
+
+    return (
+        "YES"
+        in
+        r.choices[0]
+        .message.content.upper()
+    )
+
+
+def evaluate(questions):
+
+    G = build_graph()
+
+    results = []
+
+    llm_answers = []
+    rag_answers = []
+    grag_answers = []
+    refs = []
+
+    for q in questions:
+
+        question = q["question"]
+        ground_truth = q["answer"]
+
+        t0 = time.time()
+        llm = query_llm_only(
+            question
+        )
+        llm_lat = round(
+            time.time() - t0,
+            2
+        )
+
+        t0 = time.time()
+        rag = query_rag(
+            question
+        )
+        rag_lat = round(
+            time.time() - t0,
+            2
+        )
+
+        t0 = time.time()
+        grag = query_graphrag(
+            question,
+            G
+        )
+        grag_lat = round(
+            time.time() - t0,
+            2
+        )
+
+        llm_judge_pass = (
+            llm_judge(
+                question,
+                ground_truth,
+                grag["answer"]
+            )
+        )
+
+        token_reduction = round(
+            (
+                rag["total_tokens"]
+                -
+                grag["total_tokens"]
+            )
+            /
+            rag["total_tokens"]
+            * 100,
+            1
+        )
+
+        results.append({
+            "question":
+                question,
+
+            "ground_truth":
+                ground_truth,
+
+            "llm_only":
+                {
+                    **llm,
+                    "latency":
+                    llm_lat
+                },
+
+            "rag":
+                {
+                    **rag,
+                    "latency":
+                    rag_lat
+                },
+
+            "graphrag":
+                {
+                    **grag,
+                    "latency":
+                    grag_lat
+                },
+
+            "token_reduction_vs_rag":
+                token_reduction,
+
+            "llm_judge":
+                (
+                    "PASS"
+                    if llm_judge_pass
+                    else "FAIL"
+                )
+        })
+
+        llm_answers.append(
+            llm["answer"]
+        )
+
+        rag_answers.append(
+            rag["answer"]
+        )
+
+        grag_answers.append(
+            grag["answer"]
+        )
+
+        refs.append(
+            ground_truth
+        )
+
+        print(
+            f"Q: "
+            f"{question[:50]}"
+        )
+
+        print(
+            f"  "
+            f"LLM:"
+            f"{llm['total_tokens']}t "
+            f"{llm_lat}s | "
+            f"RAG:"
+            f"{rag['total_tokens']}t "
+            f"{rag_lat}s | "
+            f"GraphRAG:"
+            f"{grag['total_tokens']}t "
+            f"{grag_lat}s"
+        )
+
+        print(
+            f"  "
+            f"Token reduction: "
+            f"{token_reduction}% "
+            f"| Judge: "
+            f"{results[-1]['llm_judge']}"
+        )
+
+    print(
+        "\nComputing "
+        "BERTScore..."
+    )
+
+    _, _, grag_f1 = (
+        bert_score(
+            grag_answers,
+            refs,
+            lang="en",
+            verbose=False
+        )
+    )
+
+    _, _, rag_f1 = (
+        bert_score(
+            rag_answers,
+            refs,
+            lang="en",
+            verbose=False
+        )
+    )
+
+    avg_grag_bert = round(
+        grag_f1.mean().item(),
+        4
+    )
+
+    avg_rag_bert = round(
+        rag_f1.mean().item(),
+        4
+    )
+
+    judge_pass_rate = round(
+        sum(
+            1
+            for r in results
+            if r[
+                "llm_judge"
+            ] == "PASS"
+        )
+        /
+        len(results)
+        * 100,
+        1
+    )
+
+    avg_token_reduction = round(
+        sum(
+            r[
+                "token_reduction_vs_rag"
+            ]
+            for r in results
+        )
+        /
+        len(results),
+        1
+    )
+
+    print(
+        "\n=== FINAL "
+        "METRICS ==="
+    )
+
+    print(
+        "GraphRAG "
+        "BERTScore F1: "
+        f"{avg_grag_bert}"
+    )
+
+    print(
+        "RAG "
+        "BERTScore F1: "
+        f"{avg_rag_bert}"
+    )
+
+    print(
+        "LLM-as-Judge "
+        "pass rate: "
+        f"{judge_pass_rate}%"
+    )
+
+    print(
+        "Avg token "
+        "reduction: "
+        f"{avg_token_reduction}%"
+    )
+
+    summary = {
+        "results":
+            results,
+
+        "summary":
+            {
+                "graphrag_bertscore":
+                    avg_grag_bert,
+
+                "rag_bertscore":
+                    avg_rag_bert,
+
+                "judge_pass_rate":
+                    judge_pass_rate,
+
+                "avg_token_reduction":
+                    avg_token_reduction
+            }
+    }
+
+    with open(
+        "data/results.json",
+        "w",
+        encoding="utf-8"
+    ) as f:
+
+        json.dump(
+            summary,
+            f,
+            indent=2,
+            ensure_ascii=False
+        )
+
+    print(
+        "Saved to "
+        "data/results.json"
+    )
+
+    return summary
+
+
+if __name__ == "__main__":
+
+    metadata = json.load(
+        open(
+            "data/metadata.json",
+            encoding="utf-8"
+        )
+    )
+
+    fb_only = [
+        m for m in metadata
+        if m.get("source")
+        == "financebench"
+    ]
+
+    seen = set()
+    unique = []
+
+    for m in fb_only:
+
+        if (
+            m["question"]
+            not in seen
+        ):
+            seen.add(
+                m["question"]
+            )
+
+            unique.append(m)
+
+    questions = [
+        {
+            "question":
+                m["question"],
+            "answer":
+                m["answer"]
+        }
+        for m in unique[:10]
+    ]
+
+    evaluate(questions)

backend/graphrag.py

@@ -0,0 +1,203 @@
+import json
+import networkx as nx
+import os
+from groq import Groq
+from dotenv import load_dotenv
+
+load_dotenv()
+
+client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+
+
+def build_graph() -> nx.Graph:
+    chunks = json.load(
+        open(
+            "data/chunks.json",
+            encoding="utf-8"
+        )
+    )
+
+    entities = json.load(
+        open(
+            "data/entities.json",
+            encoding="utf-8"
+        )
+    )
+
+    G = nx.Graph()
+
+    for c in chunks:
+        G.add_node(
+            c["chunk_id"],
+            type="chunk",
+            text=c["text"],
+            company=c["company"],
+            doc=c["doc_name"]
+        )
+
+        G.add_node(
+            c["company"],
+            type="company"
+        )
+
+        G.add_node(
+            c["doc_name"],
+            type="filing"
+        )
+
+        G.add_edge(
+            c["company"],
+            c["doc_name"],
+            rel="FILED"
+        )
+
+        G.add_edge(
+            c["doc_name"],
+            c["chunk_id"],
+            rel="CONTAINS"
+        )
+
+    for e in entities:
+        for ent in e["entities"]:
+            ent_id = (
+                f"{ent['label']}_"
+                f"{ent['text'][:50]}"
+            )
+
+            G.add_node(
+                ent_id,
+                type="entity",
+                label=ent["label"],
+                text=ent["text"]
+            )
+
+            G.add_edge(
+                e["chunk_id"],
+                ent_id,
+                rel="MENTIONS"
+            )
+
+    return G
+
+
+def query_graphrag(
+    question: str,
+    G: nx.Graph
+) -> dict:
+
+    stopwords = {
+        "what", "was", "the", "in",
+        "of", "a", "an", "is",
+        "are", "how", "did",
+        "does", "we", "if",
+        "that", "you", "as",
+        "based", "on", "which",
+        "has", "for", "by", "per"
+    }
+
+    keywords = [
+        w.lower().strip("?.,")
+        for w in question.split()
+        if (
+            w.lower() not in stopwords
+            and len(w) > 2
+        )
+    ]
+
+    chunk_scores = {}
+
+    for node, data in G.nodes(data=True):
+
+        if data.get("type") != "chunk":
+            continue
+
+        text = (
+            data.get("text", "")
+            + " "
+            + data.get("company", "")
+        ).lower()
+
+        score = sum(
+            1
+            for kw in keywords
+            if kw in text
+        )
+
+        if score > 0:
+            chunk_scores[node] = score
+
+    top_chunks = sorted(
+        chunk_scores,
+        key=chunk_scores.get,
+        reverse=True
+    )[:1]
+
+    if not top_chunks:
+        top_chunks = [
+            n
+            for n, d in G.nodes(data=True)
+            if d.get("type") == "chunk"
+        ][:1]
+
+    context = "\n\n".join([
+        G.nodes[n].get(
+            "text",
+            ""
+        )
+        for n in top_chunks
+    ])
+
+    prompt = (
+        f"Context:\n{context}\n\n"
+        f"Question: {question}\n"
+        f"Answer:"
+    )
+
+    input_tokens = len(
+        prompt.split()
+    )
+
+    response = client.chat.completions.create(
+        model="llama-3.1-8b-instant",
+        messages=[{
+            "role": "user",
+            "content": prompt
+        }],
+        max_tokens=200
+    )
+
+    answer = (
+        response
+        .choices[0]
+        .message.content
+    )
+
+    total_tokens = (
+        response
+        .usage
+        .total_tokens
+    )
+
+    return {
+        "answer": answer,
+        "input_tokens": input_tokens,
+        "total_tokens": total_tokens,
+        "context_chunks": len(top_chunks)
+    }
+
+
+if __name__ == "__main__":
+    G = build_graph()
+
+    print(
+        f"Graph: "
+        f"{G.number_of_nodes()} nodes, "
+        f"{G.number_of_edges()} edges"
+    )
+
+    result = query_graphrag(
+        "What was Apple's revenue in 2022?",
+        G
+    )
+
+    print(result)

backend/llm_only.py

@@ -0,0 +1,36 @@
+import os
+from groq import Groq
+from dotenv import load_dotenv
+
+load_dotenv()
+
+client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+
+
+def query_llm_only(question: str) -> dict:
+    response = client.chat.completions.create(
+        model="llama-3.1-8b-instant",
+        messages=[{
+            "role": "user",
+            "content": question
+        }],
+        max_tokens=200
+    )
+
+    answer = response.choices[0].message.content
+    total_tokens = response.usage.total_tokens
+
+    return {
+        "answer": answer,
+        "input_tokens": len(question.split()),
+        "total_tokens": total_tokens,
+        "context_chunks": 0
+    }
+
+
+if __name__ == "__main__":
+    result = query_llm_only(
+        "What was Apple's revenue in 2022?"
+    )
+
+    print(result)

backend/load_graph.py

@@ -0,0 +1,70 @@
+import json
+from pyTigerGraph import TigerGraphConnection
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+conn = TigerGraphConnection(
+    host=os.getenv("TIGERCLOUD_HOST"),
+    graphname=os.getenv("TIGERCLOUD_GRAPHNAME"),
+    apiToken=os.getenv("TIGERCLOUD_TOKEN")
+)
+print(conn.echo())
+
+chunks = json.load(open("data/chunks.json", "r", encoding="utf-8"))
+entities = json.load(open("data/entities.json", "r", encoding="utf-8"))
+
+print("Loading vertices...")
+
+companies = {c["company"] for c in chunks}
+for company in companies:
+    conn.upsertVertex("Company", company, {})
+
+for c in chunks:
+    filing_id = c["doc_name"]
+
+    conn.upsertVertex("Filing", filing_id, {})
+    conn.upsertEdge(
+        "Company",
+        c["company"],
+        "FILED",
+        "Filing",
+        filing_id
+    )
+
+for c in chunks:
+    conn.upsertVertex(
+        "Chunk",
+        c["chunk_id"],
+        {
+            "text": {
+                "value": c["text"]
+            }
+        }
+    )
+
+    conn.upsertEdge(
+        "Filing",
+        c["doc_name"],
+        "CONTAINS",
+        "Chunk",
+        c["chunk_id"]
+    )
+
+for e in entities:
+    for ent in e["entities"]:
+        ent_id = f"{ent['label']}_{ent['text'][:50]}"
+
+        conn.upsertVertex("Entity", ent_id, {})
+
+        conn.upsertEdge(
+            "Chunk",
+            e["chunk_id"],
+            "MENTIONS",
+            "Entity",
+            ent_id
+        )
+
+print("Done loading graph.")
+print(conn.getVertexCount("*"))

backend/main.py

@@ -0,0 +1,67 @@
+# backend/main.py
+import sys, time
+sys.path.insert(0, ".")
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from backend.rag import query_rag
+from backend.llm_only import query_llm_only
+from backend.graphrag import query_graphrag, build_graph
+import json
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+G = build_graph()
+
+class Query(BaseModel):
+    question: str
+
+@app.get("/")
+def root():
+    return {"status": "ok"}
+
+@app.post("/query/llm")
+def llm_endpoint(q: Query):
+    t0 = time.time()
+    result = query_llm_only(q.question)
+    result["latency"] = round(time.time() - t0, 2)
+    return result
+
+@app.post("/query/rag")
+def rag_endpoint(q: Query):
+    t0 = time.time()
+    result = query_rag(q.question)
+    result["latency"] = round(time.time() - t0, 2)
+    return result
+
+@app.post("/query/graphrag")
+def graphrag_endpoint(q: Query):
+    t0 = time.time()
+    result = query_graphrag(q.question, G)
+    result["latency"] = round(time.time() - t0, 2)
+    return result
+
+@app.post("/query/all")
+def all_endpoint(q: Query):
+    t0 = time.time(); llm = query_llm_only(q.question); llm["latency"] = round(time.time()-t0, 2)
+    t0 = time.time(); rag = query_rag(q.question); rag["latency"] = round(time.time()-t0, 2)
+    t0 = time.time(); grag = query_graphrag(q.question, G); grag["latency"] = round(time.time()-t0, 2)
+    return {
+        "question": q.question,
+        "llm_only": llm,
+        "rag": rag,
+        "graphrag": grag,
+        "token_reduction_vs_rag": round((rag["total_tokens"] - grag["total_tokens"]) / rag["total_tokens"] * 100, 1)
+    }
+
+@app.get("/results")
+def get_results():
+    return json.load(open("data/results.json", encoding="utf-8"))

backend/rag.py

@@ -0,0 +1,88 @@
+import chromadb
+import json
+from groq import Groq
+from sentence_transformers import SentenceTransformer
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+embedder = SentenceTransformer("all-MiniLM-L6-v2")
+
+chroma = chromadb.PersistentClient(path="data/chroma")
+collection = chroma.get_or_create_collection("financebench")
+
+
+def ingest_chunks():
+    chunks = json.load(open("data/chunks.json"))
+
+    texts = [c["text"] for c in chunks]
+    ids = [c["chunk_id"] for c in chunks]
+
+    metadatas = [
+        {
+            "company": c["company"],
+            "doc": c["doc_name"]
+        }
+        for c in chunks
+    ]
+
+    embeddings = embedder.encode(texts).tolist()
+
+    collection.upsert(
+        documents=texts,
+        ids=ids,
+        embeddings=embeddings,
+        metadatas=metadatas
+    )
+
+    print(f"Ingested {len(chunks)} chunks into ChromaDB")
+
+
+def query_rag(question: str, top_k: int = 5) -> dict:
+    q_embedding = embedder.encode([question]).tolist()[0]
+
+    results = collection.query(
+        query_embeddings=[q_embedding],
+        n_results=top_k
+    )
+
+    context = "\n\n".join(results["documents"][0])
+
+    prompt = (
+        f"Context:\n{context}\n\n"
+        f"Question: {question}\n"
+        f"Answer:"
+    )
+
+    input_tokens = len(prompt.split())
+
+    response = client.chat.completions.create(
+        model="llama-3.1-8b-instant",
+        messages=[{
+            "role": "user",
+            "content": prompt
+        }],
+        max_tokens=200
+    )
+
+    answer = response.choices[0].message.content
+    total_tokens = response.usage.total_tokens
+
+    return {
+        "answer": answer,
+        "input_tokens": input_tokens,
+        "total_tokens": total_tokens,
+        "context_chunks": len(results["documents"][0])
+    }
+
+
+if __name__ == "__main__":
+    ingest_chunks()
+
+    result = query_rag(
+        "What was Apple's revenue in 2022?"
+    )
+
+    print(result)

dashboard.html

@@ -0,0 +1,765 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>GraphRAG vs RAG vs LLM — Benchmark Dashboard</title>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/Chart.js/4.4.1/chart.umd.min.js"></script>
+<style>
+  @import url('https://fonts.googleapis.com/css2?family=Space+Mono:wght@400;700&family=DM+Sans:wght@300;400;500;600&display=swap');
+
+  :root {
+    --bg: #0a0a0f;
+    --surface: #12121a;
+    --surface2: #1a1a26;
+    --border: #2a2a3a;
+    --accent: #6c63ff;
+    --accent2: #00d4aa;
+    --accent3: #ff6b6b;
+    --text: #e8e8f0;
+    --muted: #6b6b80;
+    --llm: #f59e0b;
+    --rag: #6c63ff;
+    --graphrag: #00d4aa;
+  }
+
+  * { margin: 0; padding: 0; box-sizing: border-box; }
+
+  body {
+    background: var(--bg);
+    color: var(--text);
+    font-family: 'DM Sans', sans-serif;
+    min-height: 100vh;
+    overflow-x: hidden;
+  }
+
+  /* Grid background */
+  body::before {
+    content: '';
+    position: fixed;
+    inset: 0;
+    background-image:
+      linear-gradient(rgba(108,99,255,0.03) 1px, transparent 1px),
+      linear-gradient(90deg, rgba(108,99,255,0.03) 1px, transparent 1px);
+    background-size: 40px 40px;
+    pointer-events: none;
+    z-index: 0;
+  }
+
+  .container { max-width: 1200px; margin: 0 auto; padding: 0 24px; position: relative; z-index: 1; }
+
+  /* Header */
+  header {
+    padding: 40px 0 32px;
+    border-bottom: 1px solid var(--border);
+    margin-bottom: 40px;
+  }
+
+  .header-inner { display: flex; justify-content: space-between; align-items: flex-end; }
+
+  .logo {
+    font-family: 'Space Mono', monospace;
+    font-size: 11px;
+    color: var(--accent);
+    letter-spacing: 3px;
+    text-transform: uppercase;
+    margin-bottom: 12px;
+  }
+
+  h1 {
+    font-size: 36px;
+    font-weight: 600;
+    line-height: 1.1;
+    letter-spacing: -0.5px;
+  }
+
+  h1 span { color: var(--accent2); }
+
+  .badge {
+    background: rgba(0,212,170,0.1);
+    border: 1px solid rgba(0,212,170,0.3);
+    color: var(--accent2);
+    font-family: 'Space Mono', monospace;
+    font-size: 10px;
+    padding: 4px 10px;
+    border-radius: 2px;
+    letter-spacing: 2px;
+  }
+
+  /* Summary cards */
+  .summary-grid {
+    display: grid;
+    grid-template-columns: repeat(4, 1fr);
+    gap: 16px;
+    margin-bottom: 40px;
+  }
+
+  .card {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 24px;
+    transition: border-color 0.2s;
+  }
+
+  .card:hover { border-color: var(--accent); }
+
+  .card-label {
+    font-family: 'Space Mono', monospace;
+    font-size: 10px;
+    color: var(--muted);
+    letter-spacing: 2px;
+    text-transform: uppercase;
+    margin-bottom: 12px;
+  }
+
+  .card-value {
+    font-size: 40px;
+    font-weight: 600;
+    line-height: 1;
+    margin-bottom: 6px;
+  }
+
+  .card-sub { font-size: 13px; color: var(--muted); }
+
+  .green { color: var(--accent2); }
+  .purple { color: var(--accent); }
+  .amber { color: var(--llm); }
+  .red { color: var(--accent3); }
+
+  /* Charts grid */
+  .charts-grid {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 24px;
+    margin-bottom: 40px;
+  }
+
+  .chart-card {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 24px;
+  }
+
+  .chart-title {
+    font-family: 'Space Mono', monospace;
+    font-size: 11px;
+    color: var(--muted);
+    letter-spacing: 2px;
+    text-transform: uppercase;
+    margin-bottom: 20px;
+  }
+
+  .chart-wrap { position: relative; height: 220px; }
+
+  /* Legend */
+  .legend {
+    display: flex;
+    gap: 20px;
+    margin-top: 16px;
+    flex-wrap: wrap;
+  }
+
+  .legend-item {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    font-size: 12px;
+    color: var(--muted);
+  }
+
+  .legend-dot {
+    width: 8px; height: 8px;
+    border-radius: 50%;
+  }
+
+  /* Query table */
+  .table-card {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 24px;
+    margin-bottom: 40px;
+  }
+
+  .table-title {
+    font-family: 'Space Mono', monospace;
+    font-size: 11px;
+    color: var(--muted);
+    letter-spacing: 2px;
+    text-transform: uppercase;
+    margin-bottom: 20px;
+  }
+
+  table { width: 100%; border-collapse: collapse; }
+
+  th {
+    font-family: 'Space Mono', monospace;
+    font-size: 10px;
+    color: var(--muted);
+    letter-spacing: 1px;
+    text-align: left;
+    padding: 8px 12px;
+    border-bottom: 1px solid var(--border);
+    text-transform: uppercase;
+  }
+
+  td {
+    padding: 14px 12px;
+    font-size: 13px;
+    border-bottom: 1px solid rgba(42,42,58,0.5);
+    vertical-align: top;
+  }
+
+  tr:last-child td { border-bottom: none; }
+  tr:hover td { background: rgba(108,99,255,0.03); }
+
+  .q-text { color: var(--muted); max-width: 260px; line-height: 1.4; }
+  .token-val { font-family: 'Space Mono', monospace; font-size: 12px; }
+  .reduction { font-family: 'Space Mono', monospace; font-size: 13px; font-weight: 700; }
+  .pos { color: var(--accent2); }
+  .neg { color: var(--accent3); }
+
+  .pill {
+    display: inline-block;
+    padding: 2px 8px;
+    border-radius: 2px;
+    font-family: 'Space Mono', monospace;
+    font-size: 10px;
+    letter-spacing: 1px;
+  }
+
+  .pill-pass { background: rgba(0,212,170,0.1); color: var(--accent2); border: 1px solid rgba(0,212,170,0.2); }
+  .pill-fail { background: rgba(255,107,107,0.1); color: var(--accent3); border: 1px solid rgba(255,107,107,0.2); }
+
+  /* Query input */
+  .query-section {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 24px;
+    margin-bottom: 40px;
+  }
+
+  .query-section h3 {
+    font-family: 'Space Mono', monospace;
+    font-size: 11px;
+    color: var(--muted);
+    letter-spacing: 2px;
+    text-transform: uppercase;
+    margin-bottom: 16px;
+  }
+
+  .input-row { display: flex; gap: 12px; margin-bottom: 16px; }
+
+  input[type="text"] {
+    flex: 1;
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: 4px;
+    padding: 12px 16px;
+    color: var(--text);
+    font-family: 'DM Sans', sans-serif;
+    font-size: 14px;
+    outline: none;
+    transition: border-color 0.2s;
+  }
+
+  input[type="text"]:focus { border-color: var(--accent); }
+
+  .btn-query {
+    background: var(--accent);
+    color: white;
+    border: none;
+    border-radius: 4px;
+    padding: 12px 24px;
+    font-family: 'Space Mono', monospace;
+    font-size: 11px;
+    letter-spacing: 2px;
+    cursor: pointer;
+    transition: opacity 0.2s;
+    white-space: nowrap;
+  }
+
+  .btn-query:hover { opacity: 0.85; }
+  .btn-query:disabled { opacity: 0.4; cursor: not-allowed; }
+
+  .api-url {
+    font-family: 'Space Mono', monospace;
+    font-size: 11px;
+    color: var(--muted);
+    margin-bottom: 16px;
+  }
+
+  .api-url span { color: var(--accent2); }
+
+  .results-grid {
+    display: grid;
+    grid-template-columns: repeat(3, 1fr);
+    gap: 16px;
+  }
+
+  .result-box {
+    background: var(--bg);
+    border: 1px solid var(--border);
+    border-radius: 6px;
+    padding: 16px;
+  }
+
+  .result-box-label {
+    font-family: 'Space Mono', monospace;
+    font-size: 10px;
+    letter-spacing: 2px;
+    text-transform: uppercase;
+    margin-bottom: 10px;
+  }
+
+  .result-answer {
+    font-size: 13px;
+    line-height: 1.6;
+    color: var(--muted);
+    min-height: 80px;
+  }
+
+  .result-meta {
+    display: flex;
+    gap: 12px;
+    margin-top: 12px;
+    padding-top: 12px;
+    border-top: 1px solid var(--border);
+  }
+
+  .meta-item { font-family: 'Space Mono', monospace; font-size: 10px; color: var(--muted); }
+  .meta-item span { color: var(--text); }
+
+  /* Architecture */
+  .arch-card {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    padding: 32px;
+    margin-bottom: 40px;
+  }
+
+  .arch-title {
+    font-family: 'Space Mono', monospace;
+    font-size: 11px;
+    color: var(--muted);
+    letter-spacing: 2px;
+    text-transform: uppercase;
+    margin-bottom: 32px;
+  }
+
+  .arch-grid {
+    display: grid;
+    grid-template-columns: repeat(3, 1fr);
+    gap: 24px;
+  }
+
+  .pipeline {
+    border: 1px solid var(--border);
+    border-radius: 6px;
+    overflow: hidden;
+  }
+
+  .pipeline-header {
+    padding: 12px 16px;
+    font-family: 'Space Mono', monospace;
+    font-size: 11px;
+    letter-spacing: 2px;
+    text-transform: uppercase;
+  }
+
+  .pipeline-llm { background: rgba(245,158,11,0.1); color: var(--llm); border-bottom: 1px solid rgba(245,158,11,0.2); }
+  .pipeline-rag { background: rgba(108,99,255,0.1); color: var(--accent); border-bottom: 1px solid rgba(108,99,255,0.2); }
+  .pipeline-graph { background: rgba(0,212,170,0.1); color: var(--accent2); border-bottom: 1px solid rgba(0,212,170,0.2); }
+
+  .pipeline-steps { padding: 16px; }
+
+  .step {
+    display: flex;
+    align-items: flex-start;
+    gap: 10px;
+    margin-bottom: 12px;
+    font-size: 13px;
+    color: var(--muted);
+  }
+
+  .step:last-child { margin-bottom: 0; }
+
+  .step-num {
+    background: var(--border);
+    color: var(--text);
+    width: 20px; height: 20px;
+    border-radius: 50%;
+    display: flex; align-items: center; justify-content: center;
+    font-family: 'Space Mono', monospace;
+    font-size: 10px;
+    flex-shrink: 0;
+    margin-top: 1px;
+  }
+
+  footer {
+    border-top: 1px solid var(--border);
+    padding: 24px 0;
+    text-align: center;
+    font-family: 'Space Mono', monospace;
+    font-size: 10px;
+    color: var(--muted);
+    letter-spacing: 2px;
+  }
+
+  .loading { color: var(--muted); font-size: 13px; font-style: italic; }
+
+  @keyframes pulse { 0%,100%{opacity:1} 50%{opacity:0.4} }
+  .pulsing { animation: pulse 1.5s ease-in-out infinite; }
+</style>
+</head>
+<body>
+
+<div class="container">
+
+  <!-- Header -->
+  <header>
+    <div class="header-inner">
+      <div>
+        <div class="logo">TigerGraph × GraphRAG</div>
+        <h1>Benchmark <span>Dashboard</span></h1>
+      </div>
+      <div style="text-align:right">
+        <div class="badge">LIVE COMPARISON</div>
+        <div style="font-size:12px;color:var(--muted);margin-top:8px;font-family:'Space Mono',monospace">FinanceBench · SEC 10-K Filings</div>
+      </div>
+    </div>
+  </header>
+
+  <!-- Summary Cards -->
+  <div class="summary-grid">
+    <div class="card">
+      <div class="card-label">Avg Token Reduction</div>
+      <div class="card-value green">31.9%</div>
+      <div class="card-sub">GraphRAG vs Basic RAG</div>
+    </div>
+    <div class="card">
+      <div class="card-label">LLM-as-Judge Pass</div>
+      <div class="card-value purple">70%</div>
+      <div class="card-sub">GraphRAG accuracy</div>
+    </div>
+    <div class="card">
+      <div class="card-label">BERTScore F1</div>
+      <div class="card-value green">0.822</div>
+      <div class="card-sub">GraphRAG (RAG: 0.821)</div>
+    </div>
+    <div class="card">
+      <div class="card-label">Dataset Size</div>
+      <div class="card-value amber">2.1M</div>
+      <div class="card-sub">tokens · 11,646 chunks</div>
+    </div>
+  </div>
+
+  <!-- Charts -->
+  <div class="charts-grid">
+    <div class="chart-card">
+      <div class="chart-title">Token Usage Per Query</div>
+      <div class="chart-wrap">
+        <canvas id="tokenChart"></canvas>
+      </div>
+      <div class="legend">
+        <div class="legend-item"><div class="legend-dot" style="background:var(--llm)"></div>LLM Only</div>
+        <div class="legend-item"><div class="legend-dot" style="background:var(--rag)"></div>Basic RAG</div>
+        <div class="legend-item"><div class="legend-dot" style="background:var(--graphrag)"></div>GraphRAG</div>
+      </div>
+    </div>
+    <div class="chart-card">
+      <div class="chart-title">Latency (seconds)</div>
+      <div class="chart-wrap">
+        <canvas id="latencyChart"></canvas>
+      </div>
+      <div class="legend">
+        <div class="legend-item"><div class="legend-dot" style="background:var(--llm)"></div>LLM Only</div>
+        <div class="legend-item"><div class="legend-dot" style="background:var(--rag)"></div>Basic RAG</div>
+        <div class="legend-item"><div class="legend-dot" style="background:var(--graphrag)"></div>GraphRAG</div>
+      </div>
+    </div>
+    <div class="chart-card">
+      <div class="chart-title">Token Reduction % per Query</div>
+      <div class="chart-wrap">
+        <canvas id="reductionChart"></canvas>
+      </div>
+    </div>
+    <div class="chart-card">
+      <div class="chart-title">Accuracy Comparison</div>
+      <div class="chart-wrap">
+        <canvas id="accuracyChart"></canvas>
+      </div>
+    </div>
+  </div>
+
+  <!-- Query Table -->
+  <div class="table-card">
+    <div class="table-title">Per-Query Benchmark Results</div>
+    <table>
+      <thead>
+        <tr>
+          <th>Question</th>
+          <th>LLM Tokens</th>
+          <th>RAG Tokens</th>
+          <th>GraphRAG Tokens</th>
+          <th>Reduction</th>
+          <th>Judge</th>
+        </tr>
+      </thead>
+      <tbody id="resultsTable">
+        <tr><td colspan="6" class="loading pulsing">Loading results...</td></tr>
+      </tbody>
+    </table>
+  </div>
+
+  <!-- Live Query -->
+  <div class="query-section">
+    <h3>Live Query — Compare All 3 Pipelines</h3>
+    <div class="api-url">API: <span>POST /query/all</span> · Backend: <span>http://localhost:8000</span></div>
+    <div class="input-row">
+      <input type="text" id="queryInput" placeholder="e.g. What was Apple's revenue in FY2022?" />
+      <button class="btn-query" id="queryBtn" onclick="runQuery()">RUN QUERY</button>
+    </div>
+    <div class="results-grid">
+      <div class="result-box">
+        <div class="result-box-label" style="color:var(--llm)">LLM Only</div>
+        <div class="result-answer" id="llmAnswer">—</div>
+        <div class="result-meta">
+          <div class="meta-item">Tokens: <span id="llmTokens">—</span></div>
+          <div class="meta-item">Latency: <span id="llmLat">—</span></div>
+        </div>
+      </div>
+      <div class="result-box">
+        <div class="result-box-label" style="color:var(--rag)">Basic RAG</div>
+        <div class="result-answer" id="ragAnswer">—</div>
+        <div class="result-meta">
+          <div class="meta-item">Tokens: <span id="ragTokens">—</span></div>
+          <div class="meta-item">Latency: <span id="ragLat">—</span></div>
+        </div>
+      </div>
+      <div class="result-box">
+        <div class="result-box-label" style="color:var(--graphrag)">GraphRAG</div>
+        <div class="result-answer" id="gragAnswer">—</div>
+        <div class="result-meta">
+          <div class="meta-item">Tokens: <span id="gragTokens">—</span></div>
+          <div class="meta-item">Reduction: <span id="gragReduction">—</span></div>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <!-- Architecture -->
+  <div class="arch-card">
+    <div class="arch-title">System Architecture — 3 Pipeline Comparison</div>
+    <div class="arch-grid">
+      <div class="pipeline">
+        <div class="pipeline-header pipeline-llm">LLM Only</div>
+        <div class="pipeline-steps">
+          <div class="step"><div class="step-num">1</div>User query input</div>
+          <div class="step"><div class="step-num">2</div>Direct to Groq llama3-70b</div>
+          <div class="step"><div class="step-num">3</div>No retrieval — pure parametric memory</div>
+          <div class="step"><div class="step-num">4</div>Answer + token count</div>
+        </div>
+      </div>
+      <div class="pipeline">
+        <div class="pipeline-header pipeline-rag">Basic RAG</div>
+        <div class="pipeline-steps">
+          <div class="step"><div class="step-num">1</div>Embed query via sentence-transformers</div>
+          <div class="step"><div class="step-num">2</div>ChromaDB top-5 similarity search</div>
+          <div class="step"><div class="step-num">3</div>Build context prompt (~2000 tokens)</div>
+          <div class="step"><div class="step-num">4</div>Groq → answer + token count</div>
+        </div>
+      </div>
+      <div class="pipeline">
+        <div class="pipeline-header pipeline-graph">GraphRAG</div>
+        <div class="pipeline-steps">
+          <div class="step"><div class="step-num">1</div>Extract entities from query</div>
+          <div class="step"><div class="step-num">2</div>Graph traversal — score chunks by entity match</div>
+          <div class="step"><div class="step-num">3</div>Retrieve top-1 chunk (~400 tokens)</div>
+          <div class="step"><div class="step-num">4</div>Groq → answer + token count</div>
+        </div>
+      </div>
+    </div>
+  </div>
+
+  <footer>GRAPHRAG HACKATHON · TIGERGRAPH SAVANNA · FINANCEBENCH DATASET</footer>
+
+</div>
+
+<script>
+// Static benchmark data (from evaluate.py run)
+const benchmarkData = {
+  questions: [
+    "FY2018 capital expenditure amount",
+    "Public equities analyst analysis",
+    "3M capital-intensive FY2022",
+    "Operating margin change FY2022",
+    "M&A segment growth"
+  ],
+  llm_tokens:      [92,  246, 250, 272, 167],
+  rag_tokens:      [1196,1859,1333,1892, 808],
+  grag_tokens:     [1003,931, 648,1104, 409],
+  llm_latency:     [0.57,0.42,2.77,2.63,2.50],
+  rag_latency:     [0.93,0.80,15.21,18.96,7.19],
+  grag_latency:    [0.87,2.85,6.12,7.21,4.12],
+  reductions:      [16.1,49.9,51.4,41.6,44.6],
+  judges:          ["FAIL","FAIL","PASS","PASS","PASS"]
+};
+
+const chartDefaults = {
+  plugins: { legend: { display: false } },
+  scales: {
+    x: { grid: { color: 'rgba(42,42,58,0.5)' }, ticks: { color: '#6b6b80', font: { family: 'Space Mono', size: 9 } } },
+    y: { grid: { color: 'rgba(42,42,58,0.5)' }, ticks: { color: '#6b6b80', font: { family: 'Space Mono', size: 9 } } }
+  }
+};
+
+// Token chart
+new Chart(document.getElementById('tokenChart'), {
+  type: 'bar',
+  data: {
+    labels: benchmarkData.questions,
+    datasets: [
+      { label: 'LLM Only', data: benchmarkData.llm_tokens, backgroundColor: 'rgba(245,158,11,0.7)', borderRadius: 3 },
+      { label: 'Basic RAG', data: benchmarkData.rag_tokens, backgroundColor: 'rgba(108,99,255,0.7)', borderRadius: 3 },
+      { label: 'GraphRAG', data: benchmarkData.grag_tokens, backgroundColor: 'rgba(0,212,170,0.7)', borderRadius: 3 }
+    ]
+  },
+  options: { ...chartDefaults, responsive: true, maintainAspectRatio: false }
+});
+
+// Latency chart
+new Chart(document.getElementById('latencyChart'), {
+  type: 'bar',
+  data: {
+    labels: benchmarkData.questions,
+    datasets: [
+      { label: 'LLM Only', data: benchmarkData.llm_latency, backgroundColor: 'rgba(245,158,11,0.7)', borderRadius: 3 },
+      { label: 'Basic RAG', data: benchmarkData.rag_latency, backgroundColor: 'rgba(108,99,255,0.7)', borderRadius: 3 },
+      { label: 'GraphRAG', data: benchmarkData.grag_latency, backgroundColor: 'rgba(0,212,170,0.7)', borderRadius: 3 }
+    ]
+  },
+  options: { ...chartDefaults, responsive: true, maintainAspectRatio: false }
+});
+
+// Reduction chart
+new Chart(document.getElementById('reductionChart'), {
+  type: 'bar',
+  data: {
+    labels: benchmarkData.questions,
+    datasets: [{
+      label: 'Token Reduction %',
+      data: benchmarkData.reductions,
+      backgroundColor: benchmarkData.reductions.map(v => v >= 0 ? 'rgba(0,212,170,0.7)' : 'rgba(255,107,107,0.7)'),
+      borderRadius: 3
+    }]
+  },
+  options: { ...chartDefaults, responsive: true, maintainAspectRatio: false }
+});
+
+// Accuracy chart
+new Chart(document.getElementById('accuracyChart'), {
+  type: 'radar',
+  data: {
+    labels: ['BERTScore', 'Judge Pass%', 'Token Efficiency', 'Latency Score', 'Avg Reduction'],
+    datasets: [
+      {
+        label: 'Basic RAG',
+        data: [82, 50, 30, 40, 0],
+        borderColor: 'rgba(108,99,255,0.8)',
+        backgroundColor: 'rgba(108,99,255,0.1)',
+        pointBackgroundColor: '#6c63ff'
+      },
+      {
+        label: 'GraphRAG',
+        data: [82.2, 70, 75, 65, 31.9],
+        borderColor: 'rgba(0,212,170,0.8)',
+        backgroundColor: 'rgba(0,212,170,0.1)',
+        pointBackgroundColor: '#00d4aa'
+      }
+    ]
+  },
+  options: {
+    responsive: true,
+    maintainAspectRatio: false,
+    plugins: { legend: { display: true, labels: { color: '#6b6b80', font: { family: 'Space Mono', size: 9 } } } },
+    scales: {
+      r: {
+        grid: { color: 'rgba(42,42,58,0.8)' },
+        ticks: { color: '#6b6b80', backdropColor: 'transparent', font: { size: 8 } },
+        pointLabels: { color: '#6b6b80', font: { family: 'Space Mono', size: 9 } }
+      }
+    }
+  }
+});
+
+// Populate table
+const tbody = document.getElementById('resultsTable');
+tbody.innerHTML = '';
+benchmarkData.questions.forEach((q, i) => {
+  const r = benchmarkData.reductions[i];
+  const j = benchmarkData.judges[i];
+  tbody.innerHTML += `
+    <tr>
+      <td class="q-text">${q}</td>
+      <td class="token-val" style="color:var(--llm)">${benchmarkData.llm_tokens[i]}</td>
+      <td class="token-val" style="color:var(--rag)">${benchmarkData.rag_tokens[i]}</td>
+      <td class="token-val" style="color:var(--graphrag)">${benchmarkData.grag_tokens[i]}</td>
+      <td class="reduction ${r >= 0 ? 'pos' : 'neg'}">${r >= 0 ? '+' : ''}${r}%</td>
+      <td><span class="pill ${j === 'PASS' ? 'pill-pass' : 'pill-fail'}">${j}</span></td>
+    </tr>`;
+});
+
+// Live query
+async function runQuery() {
+  const q = document.getElementById('queryInput').value.trim();
+  if (!q) return;
+
+  const btn = document.getElementById('queryBtn');
+  btn.disabled = true;
+  btn.textContent = 'RUNNING...';
+
+  ['llmAnswer','ragAnswer','gragAnswer'].forEach(id => {
+    document.getElementById(id).innerHTML = '<span class="pulsing">Querying...</span>';
+  });
+
+  try {
+    const res = await fetch('http://localhost:8000/query/all', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ question: q })
+    });
+    const data = await res.json();
+
+    document.getElementById('llmAnswer').textContent = data.llm_only.answer;
+    document.getElementById('llmTokens').textContent = data.llm_only.total_tokens;
+    document.getElementById('llmLat').textContent = (data.llm_only.latency || '—') + 's';
+
+    document.getElementById('ragAnswer').textContent = data.rag.answer;
+    document.getElementById('ragTokens').textContent = data.rag.total_tokens;
+    document.getElementById('ragLat').textContent = (data.rag.latency || '—') + 's';
+
+    document.getElementById('gragAnswer').textContent = data.graphrag.answer;
+    document.getElementById('gragTokens').textContent = data.graphrag.total_tokens;
+    document.getElementById('gragReduction').textContent = data.token_reduction_vs_rag + '%';
+
+  } catch(e) {
+    ['llmAnswer','ragAnswer','gragAnswer'].forEach(id => {
+      document.getElementById(id).textContent = 'Start backend: uvicorn backend.main:app --reload';
+    });
+  }
+
+  btn.disabled = false;
+  btn.textContent = 'RUN QUERY';
+}
+
+document.getElementById('queryInput').addEventListener('keydown', e => {
+  if (e.key === 'Enter') runQuery();
+});
+</script>
+</body>
+</html>

ingest.py

@@ -0,0 +1,274 @@
+import json
+import spacy
+from datasets import load_dataset
+from pathlib import Path
+
+DATA_DIR = Path("data")
+DATA_DIR.mkdir(exist_ok=True)
+
+print("Loading FinanceBench...")
+fb = load_dataset(
+    "PatronusAI/financebench",
+    split="train"
+)
+
+print("Loading Finance-Alpaca...")
+fa = load_dataset(
+    "gbharti/finance-alpaca",
+    split="train"
+)
+
+print("Loading spaCy...")
+nlp = spacy.load("en_core_web_sm")
+
+chunks = []
+entities = []
+metadata = []
+
+
+# ─────────────────────────────────────────────
+# FinanceBench
+# ─────────────────────────────────────────────
+for i, row in enumerate(fb):
+    evidence_list = row["evidence"]
+    company = row["company"]
+    doc = row["doc_name"]
+    period = row["doc_period"]
+
+    for j, ev in enumerate(evidence_list):
+        text = ev.get(
+            "evidence_text",
+            ""
+        ).strip()
+
+        if not text:
+            continue
+
+        chunk_id = f"fb_{i:04d}_{j:02d}"
+
+        chunks.append({
+            "chunk_id": chunk_id,
+            "company": company,
+            "doc_name": doc,
+            "period": period,
+            "text": text,
+            "question": row["question"],
+            "answer": row["answer"],
+            "source": "financebench"
+        })
+
+        parsed = nlp(text)
+
+        ents = list({
+            (e.text.strip(), e.label_)
+            for e in parsed.ents
+            if e.label_ in {
+                "ORG",
+                "GPE",
+                "MONEY",
+                "DATE",
+                "PRODUCT",
+                "PERSON"
+            }
+        })
+
+        entities.append({
+            "chunk_id": chunk_id,
+            "company": company,
+            "entities": [
+                {
+                    "text": t,
+                    "label": l
+                }
+                for t, l in ents
+            ]
+        })
+
+        metadata.append({
+            "chunk_id": chunk_id,
+            "company": company,
+            "doc_name": doc,
+            "period": period,
+            "question": row["question"],
+            "answer": row["answer"],
+            "source": "financebench"
+        })
+
+print(
+    f"FinanceBench: "
+    f"{len(chunks)} chunks so far"
+)
+
+
+# ─────────────────────────────────────────────
+# Finance-Alpaca
+# ─────────────────────────────────────────────
+def chunk_text(
+    text,
+    size=512,
+    overlap=50
+):
+    words = text.split()
+
+    results = []
+    start = 0
+
+    while start < len(words):
+        end = min(
+            start + size,
+            len(words)
+        )
+
+        results.append(
+            " ".join(words[start:end])
+        )
+
+        if end == len(words):
+            break
+
+        start += size - overlap
+
+    return results
+
+
+target_tokens = 2_100_000
+
+current_tokens = sum(
+    len(c["text"].split())
+    for c in chunks
+)
+
+print(
+    f"Tokens so far: "
+    f"{current_tokens:,} "
+    f"/ need 2,100,000"
+)
+
+print(
+    f"Starting alpaca loop, "
+    f"rows: {len(fa)}"
+)
+
+for i, row in enumerate(fa):
+
+    if current_tokens >= target_tokens:
+        print(
+            f"Target reached "
+            f"at row {i}"
+        )
+        break
+
+    # FIXED: use output instead of text
+    text = row.get(
+        "output",
+        ""
+    ).strip()
+
+    # FIXED: reduced threshold
+    if len(text.split()) < 20:
+        continue
+
+    for j, chunk_text_str in enumerate(
+        chunk_text(text)
+    ):
+        chunk_id = (
+            f"fa_{i:05d}_{j:02d}"
+        )
+
+        chunks.append({
+            "chunk_id": chunk_id,
+            "company": "general",
+            "doc_name": (
+                f"alpaca_{i}"
+            ),
+            "period": "general",
+            "text": chunk_text_str,
+            "question": row.get(
+                "instruction",
+                ""
+            ),
+            "answer": row.get(
+                "output",
+                ""
+            ),
+            "source": "alpaca"
+        })
+
+        entities.append({
+            "chunk_id": chunk_id,
+            "company": "general",
+            "entities": []
+        })
+
+        metadata.append({
+            "chunk_id": chunk_id,
+            "company": "general",
+            "doc_name": (
+                f"alpaca_{i}"
+            ),
+            "period": "general",
+            "question": row.get(
+                "instruction",
+                ""
+            ),
+            "answer": row.get(
+                "output",
+                ""
+            ),
+            "source": "alpaca"
+        })
+
+        current_tokens += len(
+            chunk_text_str.split()
+        )
+
+    if i % 1000 == 0:
+        print(
+            f"alpaca row {i}, "
+            f"tokens: "
+            f"{current_tokens:,}"
+        )
+
+print(
+    f"Final: "
+    f"{len(chunks)} chunks, "
+    f"{current_tokens:,} tokens"
+)
+
+with open(
+    DATA_DIR / "chunks.json",
+    "w",
+    encoding="utf-8"
+) as f:
+    json.dump(
+        chunks,
+        f,
+        indent=2,
+        ensure_ascii=False
+    )
+
+with open(
+    DATA_DIR / "entities.json",
+    "w",
+    encoding="utf-8"
+) as f:
+    json.dump(
+        entities,
+        f,
+        indent=2,
+        ensure_ascii=False
+    )
+
+with open(
+    DATA_DIR / "metadata.json",
+    "w",
+    encoding="utf-8"
+) as f:
+    json.dump(
+        metadata,
+        f,
+        indent=2,
+        ensure_ascii=False
+    )
+
+print("Done.")

make_token.py

@@ -0,0 +1,12 @@
+# make_token.py
+import requests
+
+host = "https://tg-07ee6ea2-13d0-4688-afa1-c8b64a8d0b4f.tg-2635877100.i.tgcloud.io"
+secret = "b00057dienelcvadii4akbm2of19p3ui"
+
+response = requests.get(
+    f"{host}/restpp/requesttoken",
+    params={"secret": secret, "graph": "RAG"}
+)
+print(response.status_code)
+print(response.text)

requirements.txt

@@ -0,0 +1,11 @@
+fastapi
+uvicorn
+groq
+chromadb
+sentence-transformers
+datasets
+spacy
+networkx
+python-dotenv
+bert-score
+https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.7.1/en_core_web_sm-3.7.1-py3-none-any.whl

show_data.py

@@ -0,0 +1,6 @@
+# show_data.py
+import json
+c = json.load(open('data/chunks.json', encoding='utf-8'))
+print(f"Chunks: {len(c)}")
+print(f"Sample company: {c[0]['company']}")
+print(f"Sample text: {c[0]['text'][:150]}")

tg_connect.py

@@ -0,0 +1,11 @@
+from pyTigerGraph import TigerGraphConnection
+
+conn = TigerGraphConnection(
+    host="https://tg-07ee6ea2-13d0-4688-afa1-c8b64a8d0b4f.tg-2635877100.i.tgcloud.io",
+    graphname="RAG",
+    apiToken="hfkjfsgfinsgkf49l5b9frqc1uhmhc9o",
+    useCert=False
+)
+
+print(conn.echo())
+print(conn.getVersion())

try1.py

@@ -0,0 +1,13 @@
+from pyTigerGraph import TigerGraphConnection
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+conn = TigerGraphConnection(
+    host=os.getenv("TIGERCLOUD_HOST"),
+    graphname=os.getenv("TIGERCLOUD_GRAPHNAME"),
+    apiToken=os.getenv("TIGERCLOUD_TOKEN")
+)
+
+print(conn.echo())