Expand corpus to 18 companies (recent SEC 10-Ks); ship prebuilt index via git-lfs

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+vectorstore/** filter=lfs diff=lfs merge=lfs -text

app.py

@@ -34,10 +34,10 @@ with st.sidebar:
 
 # --- starter questions (clickable examples) ---------------------------------
 STARTER_QUESTIONS = [
-    "What are AMD's main business risks?",
-    "What are Abbott's business segments?",
-    "What is Air Products' primary business?",
-    "What does Matson's logistics business do?",
+    "What are Boeing's business segments?",
+    "What are the main risks AMD identifies?",
+    "What products and services does Microsoft offer?",
+    "Which geographies does PepsiCo operate in?",
 ]
 
 # --- chat history -----------------------------------------------------------

eval/run_eval.py

@@ -1,9 +1,11 @@
-"""Evaluate FinChat on the curated gold set with an LLM-as-judge score.
+"""Evaluate FinChat against the FinanceBench benchmark (corpus-aligned subset).
 
-For each question, FinChat produces an answer, then a separate LLM "judge"
-grades that answer against the reference: CORRECT (1.0), PARTIAL (0.5), or
-INCORRECT (0.0). Results and the overall accuracy are written to
-eval/results.md.
+Runs FinChat on every FinanceBench 10-K question whose company + fiscal year is
+present in our EDGAR corpus, then grades each answer against FinanceBench's gold
+answer with an LLM-as-judge. Writes eval/results.md.
+
+FinanceBench is a deliberately hard, expert-written benchmark, so the goal is an
+honest, measured score on real questions — not a perfect one.
 
 Run from the project root:
     python -m eval.run_eval
@@ -18,21 +20,54 @@ from pathlib import Path
 # Make `src` and `eval` importable no matter how this is launched.
 sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
 
+from datasets import load_dataset
 from langchain_core.prompts import ChatPromptTemplate
+from langchain_groq import ChatGroq
 
+from src import config
 from src.rag import answer, get_llm
-from eval.gold_set import GOLD_SET
+
+# Cap the number of questions so a full run fits Groq's free-tier daily token
+# budget. Sampled with an even stride across companies for representativeness.
+MAX_QUESTIONS = 30
+# Grade with a small, cheap, high-rate-limit model (judging is easy); this
+# keeps the expensive 70B model's token budget for answering.
+JUDGE_MODEL = "llama-3.1-8b-instant"
+_judge_llm = None
+
+
+def get_judge_llm() -> ChatGroq:
+    global _judge_llm
+    if _judge_llm is None:
+        _judge_llm = ChatGroq(model=JUDGE_MODEL, temperature=0.0, max_retries=5)
+    return _judge_llm
+
+# Windows consoles default to cp1252 and crash when print() emits Unicode
+# (curly quotes etc. from FinanceBench questions). Force UTF-8 output.
+try:
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+except Exception:
+    pass
+
+# FinanceBench company name -> ticker (aligned with config.TARGET_FILINGS).
+FB_COMPANY_TO_TICKER = {
+    "AMD": "AMD", "American Express": "AXP", "Boeing": "BA", "PepsiCo": "PEP",
+    "Amcor": "AMCR", "3M": "MMM", "Johnson & Johnson": "JNJ", "CVS Health": "CVS",
+    "Pfizer": "PFE", "AES Corporation": "AES", "Verizon": "VZ", "Best Buy": "BBY",
+    "Adobe": "ADBE", "Ulta Beauty": "ULTA", "Coca-Cola": "KO", "Microsoft": "MSFT",
+    "Nike": "NKE", "Corning": "GLW",
+}
 
 JUDGE_PROMPT = ChatPromptTemplate.from_messages(
     [
         (
             "system",
             "You grade a financial question-answering system against a reference "
-            "answer.\n"
-            "Grade CORRECT if the system answer conveys the key facts of the "
-            "reference (minor omissions or extra detail are fine), PARTIAL if it "
-            "captures some but misses important parts, and INCORRECT if it is "
-            "wrong, empty, or unsupported.\n"
+            "answer from the FinanceBench benchmark.\n"
+            "Grade CORRECT if the system answer agrees with the reference on the "
+            "key fact(s) or number(s) (minor wording or rounding is fine), "
+            "PARTIAL if it is partially right or incomplete, and INCORRECT if it "
+            "is wrong, empty, or says it cannot find the answer.\n"
             "Respond in EXACTLY this format:\n"
             "VERDICT: <CORRECT|PARTIAL|INCORRECT>\n"
             "REASON: <one short sentence>",
@@ -44,12 +79,11 @@ JUDGE_PROMPT = ChatPromptTemplate.from_messages(
         ),
     ]
 )
-
 SCORE = {"CORRECT": 1.0, "PARTIAL": 0.5, "INCORRECT": 0.0}
 
 
 def judge(question: str, reference: str, system: str) -> tuple[str, str]:
-    text = (JUDGE_PROMPT | get_llm()).invoke(
+    text = (JUDGE_PROMPT | get_judge_llm()).invoke(
         {"question": question, "reference": reference, "system": system}
     ).content
     v = re.search(r"VERDICT:\s*(CORRECT|PARTIAL|INCORRECT)", text, re.I)
@@ -59,46 +93,85 @@ def judge(question: str, reference: str, system: str) -> tuple[str, str]:
     return verdict, reason
 
 
+def select_questions() -> list[dict]:
+    """FinanceBench 10-K questions whose (company, fiscal year) is in our corpus."""
+    ingested = {(t, str(y)) for t, _name, y in config.TARGET_FILINGS}
+    fb = load_dataset("PatronusAI/financebench", split="train")
+    picked = []
+    for ex in fb:
+        if "10K" not in str(ex.get("doc_name", "")):
+            continue
+        ticker = FB_COMPANY_TO_TICKER.get(str(ex.get("company")))
+        if ticker and (ticker, str(ex.get("doc_period"))) in ingested:
+            picked.append(ex)
+    return picked
+
+
 def main() -> None:
+    rows = select_questions()
+    if len(rows) > MAX_QUESTIONS:                    # even-stride sample
+        stride = len(rows) // MAX_QUESTIONS
+        rows = rows[::stride][:MAX_QUESTIONS]
+    print(f"Evaluating {len(rows)} corpus-aligned FinanceBench 10-K questions.\n")
+
     results = []
     total = 0.0
-
-    for i, item in enumerate(GOLD_SET, 1):
-        res = answer(item["question"])
-        verdict, reason = judge(item["question"], item["reference"], res["answer"])
+    for ex in rows:
+        res = answer(ex["question"])
+        verdict, reason = judge(ex["question"], ex.get("answer", ""), res["answer"])
         total += SCORE[verdict]
-        results.append((item, res, verdict, reason))
-        print(f"[{verdict:9}] {item['company']:5} {item['question']}")
-        time.sleep(1.0)   # be gentle with the free-tier rate limit
+        results.append((ex, res, verdict, reason))
+        print(f"[{verdict:9}] {ex.get('company')}: {ex['question'][:70]}")
+        time.sleep(1.0)   # ease off the free-tier rate limit
 
-    n = len(GOLD_SET)
+    n = len(rows)
     accuracy = total / n if n else 0.0
-    correct = sum(1 for _, _, v, _ in results if v == "CORRECT")
-    partial = sum(1 for _, _, v, _ in results if v == "PARTIAL")
+    correct = sum(1 for _e, _r, v, _j in results if v == "CORRECT")
+    partial = sum(1 for _e, _r, v, _j in results if v == "PARTIAL")
 
     lines = [
-        "# FinChat Evaluation — Curated Gold Set\n",
-        "FinChat is graded by an LLM-as-judge against reference answers written "
-        "from the 2017-2020 10-K filings in the corpus.\n",
-        f"- **Questions:** {n}",
+        "# FinChat Evaluation — FinanceBench (corpus-aligned subset)\n",
+        "FinChat is graded by an LLM-as-judge against gold answers from the "
+        "[FinanceBench](https://huggingface.co/datasets/PatronusAI/financebench) "
+        "benchmark, on every 10-K question whose company + fiscal year is in the "
+        "corpus. FinanceBench is expert-written and intentionally hard.\n",
+        f"- **Questions evaluated:** {n}",
         f"- **CORRECT:** {correct}   **PARTIAL:** {partial}   "
         f"**INCORRECT:** {n - correct - partial}",
         f"- **Score:** {total:.1f} / {n}",
         f"- **Accuracy (CORRECT=1.0, PARTIAL=0.5):** {accuracy:.0%}\n",
-        "| # | Company | Verdict | Question |",
-        "|---|---------|---------|----------|",
     ]
-    for i, (item, _res, verdict, _reason) in enumerate(results, 1):
-        lines.append(f"| {i} | {item['company']} | {verdict} | {item['question']} |")
+
+    # Accuracy by FinanceBench question type -> shows the qualitative-vs-numeric
+    # split (metrics-generated questions require computation over tables).
+    by_type: dict[str, list[float]] = {}
+    for ex, _res, verdict, _reason in results:
+        agg = by_type.setdefault(str(ex.get("question_type", "unknown")), [0.0, 0])
+        agg[0] += SCORE[verdict]
+        agg[1] += 1
+    print("\nAccuracy by question type:")
+    lines += ["**Accuracy by FinanceBench question type:**\n",
+              "| Question type | Accuracy | N |", "|---|---|---|"]
+    for qt, (s, c) in sorted(by_type.items()):
+        print(f"  {qt:24} {s / c:.0%}  ({c})")
+        lines.append(f"| {qt} | {s / c:.0%} | {c} |")
+
+    lines += ["\n| # | Company | FY | Verdict | Question |",
+              "|---|---------|----|---------|----------|"]
+    for i, (ex, _res, verdict, _reason) in enumerate(results, 1):
+        q = ex["question"].replace("|", "\\|")
+        lines.append(
+            f"| {i} | {ex.get('company')} | {ex.get('doc_period')} | {verdict} | {q} |"
+        )
 
     lines += ["\n---\n", "## Detailed results\n"]
-    for i, (item, res, verdict, reason) in enumerate(results, 1):
+    for i, (ex, res, verdict, reason) in enumerate(results, 1):
         lines += [
-            f"### {i}. {item['question']}",
-            f"- **Company:** {item['company']}  |  "
+            f"### {i}. {ex['question']}",
+            f"- **Company / FY:** {ex.get('company')} {ex.get('doc_period')}  |  "
             f"**Routed to:** {res['routed_to']}  |  **Verdict:** {verdict}",
             f"- **Judge:** {reason}",
-            f"- **Reference:** {item['reference']}",
+            f"- **FinanceBench gold:** {ex.get('answer', '')}",
             f"- **FinChat:** {res['answer']}\n",
         ]
 

requirements.txt

@@ -18,8 +18,11 @@ chromadb==1.5.9
 # --- Embedding model runtime (pulls in torch, CPU is fine) ---
 sentence-transformers==5.6.0
 
-# --- Data loading ---
-# datasets must stay <3.0: this dataset ships a loader script, and
+# --- SEC filings source ---
+edgartools==5.40.1               # fetches & extracts 10-K text from SEC EDGAR
+
+# --- Data loading (FinanceBench evaluation set) ---
+# datasets must stay <3.0: FinanceBench-adjacent script datasets need it, and
 # datasets>=3.0 removed support for script-based datasets.
 datasets==2.21.0
 pandas==3.0.3

src/config.py

@@ -18,30 +18,51 @@ DATA_DIR = PROJECT_ROOT / "data"
 #     writable, which makes chromadb's storage engine fail to start -> use
 #     /tmp, which is writable in any container.
 # Override either default with the FINCHAT_VECTORSTORE env var.
+_repo_store = PROJECT_ROOT / "vectorstore"      # prebuilt index committed to repo
 _default_store = (
     Path.home() / ".finchat" / "vectorstore"
     if os.name == "nt"
     else Path("/tmp/finchat/vectorstore")
 )
-VECTORSTORE_DIR = Path(os.getenv("FINCHAT_VECTORSTORE", str(_default_store)))
-
-# --- Dataset (Hugging Face) -------------------------------------------------
-# Each row is ONE sentence from a 10-K filing. ingest.py reassembles the
-# sentences into section text before chunking. "small_full" (~240k sentences)
-# keeps the download light enough for a laptop.
-HF_DATASET = "JanosAudran/financial-reports-sec"
-HF_CONFIG = "small_full"
-HF_SPLIT = "train"
-
-# --- Corpus scope -----------------------------------------------------------
-# Which companies to ingest. Leave TARGET_TICKERS = [] to auto-pick the
-# TOP_N_COMPANIES with the most content (handy before you know what's in the
-# data -- run `python -m src.ingest --list` to see the options).
-# Recognizable companies available in the "small_full" config, recent years.
-# Swap freely: also available -> CECE, BKTI, ACU, AE, WDDD (all end at 2020).
-TARGET_TICKERS: list[str] = ["AMD", "ABT", "APD", "AIR", "MATX"]
-TARGET_YEARS: list[int] = [2017, 2018, 2019, 2020]
-TOP_N_COMPANIES = 8                 # used only when TARGET_TICKERS is empty
+if os.getenv("FINCHAT_VECTORSTORE"):
+    VECTORSTORE_DIR = Path(os.environ["FINCHAT_VECTORSTORE"])
+elif (_repo_store / "chroma.sqlite3").exists():
+    # A prebuilt index shipped with the repo (e.g. on Hugging Face Spaces) —
+    # use it directly so the app never rebuilds on startup.
+    VECTORSTORE_DIR = _repo_store
+else:
+    VECTORSTORE_DIR = _default_store
+
+# --- SEC EDGAR corpus -------------------------------------------------------
+# Recent 10-K filings for recognizable companies, fetched from SEC EDGAR via
+# edgartools. The set overlaps with the FinanceBench benchmark (matching
+# company + fiscal year), so FinChat can be scored against it.
+# SEC requires a contact identity (name/email) on every request.
+EDGAR_IDENTITY = "narendra.daffa08@gmail.com"
+
+# (ticker, display name, fiscal year). fiscal_year matches the filing's
+# period_of_report year, which correctly handles offset fiscal years
+# (e.g. Amcor closes in June, Nike in May).
+TARGET_FILINGS = [
+    ("AMD",  "Advanced Micro Devices", 2022),
+    ("AXP",  "American Express",        2022),
+    ("BA",   "Boeing",                  2022),
+    ("PEP",  "PepsiCo",                 2022),
+    ("AMCR", "Amcor",                   2023),
+    ("MMM",  "3M",                      2022),
+    ("JNJ",  "Johnson & Johnson",       2022),
+    ("CVS",  "CVS Health",              2022),
+    ("PFE",  "Pfizer",                  2021),
+    ("AES",  "AES Corporation",         2022),
+    ("VZ",   "Verizon",                 2022),
+    ("BBY",  "Best Buy",                2023),
+    ("ADBE", "Adobe",                   2022),
+    ("ULTA", "Ulta Beauty",             2023),
+    ("KO",   "Coca-Cola",               2022),
+    ("MSFT", "Microsoft",               2023),
+    ("NKE",  "Nike",                    2023),
+    ("GLW",  "Corning",                 2022),
+]
 
 # --- Chunking ---------------------------------------------------------------
 CHUNK_SIZE = 900                    # characters per chunk

src/ingest.py

@@ -1,17 +1,14 @@
-"""Build the FinChat vector store from SEC 10-K filings.
+"""Build the FinChat vector store from recent SEC 10-K filings (EDGAR).
 
 Pipeline:
-    load sentences  ->  group into section text  ->  split into chunks
-    ->  embed locally  ->  store in Chroma (persisted to ./vectorstore)
+    fetch each target 10-K (edgartools)  ->  split into chunks
+    ->  embed locally  ->  store in Chroma (persisted to config.VECTORSTORE_DIR)
 
-Run it once (from the project root):
-    python -m src.ingest            # build the vector store
-    python -m src.ingest --list     # just list available companies, then exit
+Run once, from the project root:
+    python -m src.ingest
 """
 from __future__ import annotations
 
-import argparse
-import re
 import shutil
 import sys
 import time
@@ -20,8 +17,7 @@ from pathlib import Path
 # Allow running as either `python -m src.ingest` or `python src/ingest.py`.
 sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
 
-import pandas as pd
-from datasets import load_dataset
+from edgar import Company, set_identity
 from langchain_core.documents import Document
 from langchain_text_splitters import RecursiveCharacterTextSplitter
 from langchain_huggingface import HuggingFaceEmbeddings
@@ -29,105 +25,60 @@ from langchain_chroma import Chroma
 
 from src import config
 
+# Windows consoles default to cp1252 and crash when print() emits Unicode
+# (arrows, em-dashes, curly quotes from filings). Force UTF-8 output.
+try:
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+except Exception:
+    pass
 
-def pretty_section(label: str) -> str:
-    """Turn a raw section label into a readable 'Section N' for display."""
-    nums = re.findall(r"\d+", str(label))
-    if nums:
-        return f"Section {nums[-1]}"
-    return str(label).replace("_", " ").strip().title() or "Filing"
 
+def fetch_filing(ticker: str, fiscal_year: int) -> tuple[str, str] | None:
+    """Return (text, accession_no) for the 10-K whose fiscal period matches.
 
-def load_dataframe() -> pd.DataFrame:
-    """Download the dataset split and return it as a tidy DataFrame."""
-    print(f"Loading {config.HF_DATASET} [{config.HF_CONFIG}] ... (first run downloads it)")
-    ds = load_dataset(
-        config.HF_DATASET, config.HF_CONFIG, split=config.HF_SPLIT,
-        trust_remote_code=True,
-    )
-    df = ds.to_pandas()
+    Matches on the filing's period_of_report year, so an offset fiscal year
+    (e.g. Amcor's June close) still resolves to the right filing.
+    """
+    for f in Company(ticker).get_filings(form="10-K"):
+        period = getattr(f, "period_of_report", None)
+        if period and str(period)[:4] == str(fiscal_year):
+            return f.text(), f.accession_no
+    return None
 
-    # `tickers` is a list per row -> take the first as the primary ticker.
-    df["ticker"] = df["tickers"].apply(
-        lambda t: t[0] if hasattr(t, "__len__") and len(t) else None
-    )
-    # reportDate looks like "2020-09-26"; the year is the first 4 chars.
-    df["year"] = df["reportDate"].astype(str).str.slice(0, 4)
-    return df
-
-
-def list_companies(df: pd.DataFrame, top: int = 30) -> None:
-    counts = (
-        df.dropna(subset=["ticker"])
-        .groupby(["ticker", "name"])
-        .size()
-        .sort_values(ascending=False)
-        .head(top)
-    )
-    print("\nTop companies available (ticker | name | #sentences):")
-    for (ticker, name), n in counts.items():
-        print(f"  {ticker:<8} {str(name):<42} {n}")
-    print("\nCopy the tickers you want into TARGET_TICKERS in src/config.py.")
-
-
-def select_rows(df: pd.DataFrame) -> pd.DataFrame:
-    df = df.dropna(subset=["ticker"]).copy()
-
-    if config.TARGET_YEARS:
-        years = {str(y) for y in config.TARGET_YEARS}
-        df = df[df["year"].isin(years)]
-
-    if config.TARGET_TICKERS:
-        wanted = {t.upper() for t in config.TARGET_TICKERS}
-        df = df[df["ticker"].str.upper().isin(wanted)]
-    else:
-        # No explicit list -> keep the TOP_N companies by content volume.
-        top = (
-            df.groupby("ticker").size()
-            .sort_values(ascending=False)
-            .head(config.TOP_N_COMPANIES)
-            .index
-        )
-        df = df[df["ticker"].isin(top)]
-
-    return df
-
-
-def build_documents(df: pd.DataFrame) -> list[Document]:
-    """Reassemble sentences into section text, then split into chunks."""
-    # One "raw document" per (filing, section). docID identifies one filing.
-    grouped = df.sort_values("sentenceCount").groupby(["docID", "section"])
-
-    raw_docs: list[Document] = []
-    for (doc_id, section), rows in grouped:
-        text = " ".join(str(s) for s in rows["sentence"].tolist()).strip()
-        if len(text) < 50:                 # skip near-empty sections
-            continue
-        head = rows.iloc[0]
-        company = str(head["name"])
-        year = str(head["year"])
-        raw_docs.append(
-            Document(
-                page_content=text,
-                metadata={
-                    "ticker": str(head["ticker"]),
-                    "company": company,
-                    "year": year,
-                    "section": str(section),
-                    "cik": str(head["cik"]),
-                    "docID": str(doc_id),
-                    "source": f"{company} 10-K ({year}) - {pretty_section(section)}",
-                },
-            )
-        )
 
+def fetch_documents() -> list[Document]:
+    """Fetch every target filing and split it into chunked LangChain Documents."""
+    set_identity(config.EDGAR_IDENTITY)
     splitter = RecursiveCharacterTextSplitter(
         chunk_size=config.CHUNK_SIZE,
         chunk_overlap=config.CHUNK_OVERLAP,
     )
-    chunks = splitter.split_documents(raw_docs)
-    print(f"Reassembled {len(raw_docs)} sections -> {len(chunks)} chunks.")
-    return chunks
+
+    docs: list[Document] = []
+    for ticker, name, year in config.TARGET_FILINGS:
+        print(f"Fetching {ticker} FY{year} 10-K ...", end=" ", flush=True)
+        result = fetch_filing(ticker, year)
+        if result is None:
+            print("NOT FOUND -- skipping")
+            continue
+        text, accession = result
+        source = f"{name} 10-K (FY{year})"
+        for chunk in splitter.split_text(text):
+            docs.append(
+                Document(
+                    page_content=chunk,
+                    metadata={
+                        "ticker": ticker,
+                        "company": name,
+                        "year": str(year),
+                        "accession": accession,
+                        "source": source,
+                    },
+                )
+            )
+        print(f"{len(text):,} chars -> {len(docs)} chunks so far")
+        time.sleep(0.5)   # be polite to SEC's servers
+    return docs
 
 
 def _safe_rmtree(path: Path, retries: int = 3) -> None:
@@ -138,7 +89,7 @@ def _safe_rmtree(path: Path, retries: int = 3) -> None:
             return
         except (PermissionError, OSError):
             time.sleep(1.0)
-    shutil.rmtree(path)   # last try -- let the error surface if it still fails
+    shutil.rmtree(path)
 
 
 def build_vectorstore(chunks: list[Document]) -> None:
@@ -150,7 +101,7 @@ def build_vectorstore(chunks: list[Document]) -> None:
     print(f"Loading embedding model {config.EMBEDDING_MODEL} ...")
     embeddings = HuggingFaceEmbeddings(model_name=config.EMBEDDING_MODEL)
 
-    print("Embedding & storing chunks (this can take a few minutes) ...")
+    print(f"Embedding & storing {len(chunks)} chunks (a few minutes) ...")
     Chroma.from_documents(
         documents=chunks,
         embedding=embeddings,
@@ -161,34 +112,18 @@ def build_vectorstore(chunks: list[Document]) -> None:
 
 
 def build_index() -> None:
-    """Run the full ingestion pipeline: load -> select -> chunk -> embed -> store.
+    """Full pipeline: fetch filings -> chunk -> embed -> store.
 
-    Importable so the app can bootstrap the vector store on first run
-    (e.g. on a fresh Hugging Face Space).
+    Importable so the app can bootstrap the store on first run.
     """
-    df = load_dataframe()
-    selected = select_rows(df)
-    if selected.empty:
-        raise SystemExit(
-            "\nNo rows matched TARGET_TICKERS / TARGET_YEARS in src/config.py.\n"
-            "Run `python -m src.ingest --list` to see what's available."
-        )
-    companies = sorted(selected["ticker"].unique())
-    print(f"Ingesting {len(companies)} companies: {', '.join(companies)}")
-    chunks = build_documents(selected)
-    build_vectorstore(chunks)
+    docs = fetch_documents()
+    if not docs:
+        raise SystemExit("No filings were fetched — check tickers/years in config.py.")
+    print(f"Total: {len(docs)} chunks from {len(config.TARGET_FILINGS)} target filings.")
+    build_vectorstore(docs)
 
 
 def main() -> None:
-    parser = argparse.ArgumentParser(description="Build the FinChat vector store.")
-    parser.add_argument("--list", action="store_true",
-                        help="List available companies and exit.")
-    args = parser.parse_args()
-
-    if args.list:
-        list_companies(load_dataframe())
-        return
-
     build_index()
 
 

vectorstore/5e736a2d-5524-4786-879f-5e5bfddfc2b6/data_level0.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c6b529e7f484c17ad5a211753037d3fd28fd20e1ccbd9f9358289b6a69c4be31
+size 27018796

vectorstore/5e736a2d-5524-4786-879f-5e5bfddfc2b6/header.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bcdaa3a4152103e1edc94b56aad83a3557a6828134c42d68f9260717e1f9f243
+size 100

vectorstore/5e736a2d-5524-4786-879f-5e5bfddfc2b6/index_metadata.pickle

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54c22b54ab9f504cadfc301b506ca9f2b0b7769736bc624af5fa2402d09716cc
+size 1483324

vectorstore/5e736a2d-5524-4786-879f-5e5bfddfc2b6/length.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:034a92141994e5554a9ca608b1f904f4c4a35b65799fffad10c0086c0505943e
+size 64484

vectorstore/5e736a2d-5524-4786-879f-5e5bfddfc2b6/link_lists.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ddeffe7ec74e3fc7fbdf981a4b7e3d733cdcaabe2aa54b6446ccd870654afe9
+size 139012

vectorstore/chroma.sqlite3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1ab762371a44ad19ed423c7b6c4d3b94432832e17dca56a2cab388d02882ebe1
+size 99049472