feat: migrate vector store from ChromaDB to Astra DB + Astra Vectorize

core/database.py — complete rewrite
- Remove all chromadb / sentence-transformers / ONNX runtime dependencies
- Integrate DataStax Astra DB via astrapy DataAPIClient
- Collection "pestel_signals" created with Astra Vectorize:
provider=nvidia, model=NV-Embed-QA (1024-dim, cosine)
No local model or external embedding API call — Astra embeds server-side
- Signal._to_astra_doc(): maps Signal → Astra document (_id, $vectorize, fields)
- Signal._from_astra_doc(): reconstructs Signal from Astra document
(accepts both native lists and legacy JSON strings for entities/themes)
- SignalDB._get_or_create_collection(): idempotent bootstrap on first init
- SignalDB.insert(): find_one_and_replace(..., upsert=True) — safe re-ingestion
- SignalDB.search(): find(..., sort={"$vectorize": query}, include_similarity=True)
converts Astra similarity [0,1] → distance convention (1.0 − similarity)
to preserve all existing threshold logic in pipeline.py and graph_engine.py
- SignalDB.get_all(): limit=2_000, $vector excluded from projection
- SignalDB.count(): count_documents({}, upper_bound=10_000) — no full scan
- SignalDB.clear(): drop_collection then recreate with vectorize config
- Signal.to_metadata() / from_metadata() unchanged — graph_engine contract

requirements.txt
- Add astrapy>=1.5.0

.env.example
- Add ASTRA_DB_TOKEN documentation

core/logger.py
- Replace "chromadb" with "astrapy", "httpcore" in noise-suppressed loggers

app.py, core/pipeline.py, core/graph_engine.py, core/scheduler.py
- Update all "ChromaDB" user-facing strings and docstrings → "Astra DB"

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.env.example

@@ -1,10 +1,18 @@
-# Anthropic API Key for Claude Code CLI Authentication
-# Get your API key from: https://console.anthropic.com/settings/keys
-# IMPORTANT: This will charge your Anthropic API account (pay-as-you-go rates)
-# Copy this file to .env and add your actual API key
+# ── Fendt PESTEL-EL Sentinel — environment variables ─────────────────────────
+# Copy this file to .env and fill in your actual values.
+# NEVER commit .env to version control.
 
-ANTHROPIC_API_KEY=sk-ant-api03-your-key-here
+# ── HuggingFace (LLM scoring + graph edge identification) ─────────────────────
+# Get your token from: https://huggingface.co/settings/tokens
+HUGGINGFACEHUB_API_TOKEN=hf_your_token_here
 
-# n8n Configuration (already set in docker-compose, can override here)
-# N8N_BASIC_AUTH_USER=admin
-# N8N_BASIC_AUTH_PASSWORD=fendt2026
+# ── Astra DB (primary vector store for PESTEL signals) ────────────────────────
+# Generate an Application Token in the Astra DB console:
+#   https://astra.datastax.com → Database → Connect → Application Token
+ASTRA_DB_TOKEN=AstraCS:your_token_here
+
+# ── Optional: Firecrawl (HTML page scraping fallback) ─────────────────────────
+# FIRECRAWL_API_KEY=fc-your_key_here
+
+# ── Optional: log verbosity (DEBUG | INFO | WARNING | ERROR) ──────────────────
+# LOG_LEVEL=INFO

app.py

@@ -6,7 +6,7 @@ Architecture rules (CLAUDE.md):
   - Callbacks are pure functions. No global state mutation.
   - All Plotly colors use rgba() — never 8-char hex (#rrggbbaa).
   - All chart builders tested in _preflight() before Dash starts.
-  - ChromaDB access only via SignalDB. Never call chroma directly.
+  - Astra DB access only via SignalDB. Never call astrapy directly.
   - Styling via CSS className. Inline style only for dynamic values.
 
 Sponsor requirements implemented:
@@ -580,7 +580,7 @@ def _tab_overview() -> html.Div:
         html.Div("KEY METRICS", className="section-label"),
         dbc.Row([
             dbc.Col(_metric("Total Signals",   str(total) if total else "—",
-                            "in ChromaDB", "cyan"), md=3),
+                            "in Astra DB", "cyan"), md=3),
             dbc.Col(_metric("Critical",        str(stats["critical"]) if total else "—",
                             "score ≥ 0.75", "red"), md=3),
             dbc.Col(_metric("High",            str(stats["high"]) if total else "—",
@@ -683,7 +683,7 @@ def _tab_feed() -> html.Div:
         dbc.Row([
             dbc.Col([
                 html.Div(
-                    f"{len(signals)} signal(s) · sorted newest first · live from ChromaDB",
+                    f"{len(signals)} signal(s) · sorted newest first · live from Astra DB",
                     style={"fontSize": "11px", "color": "#3d4f62", "marginBottom": "16px"},
                 ),
                 html.Div(
@@ -725,7 +725,7 @@ def _tab_chatbot(history: list[dict] | None = None) -> html.Div:
 
     welcome = _chat_bubble(
         f"Fendt Intelligence Assistant\n\n"
-        f"{db_count} signal(s) indexed in ChromaDB. HuggingFace: {hf_status}\n\n"
+        f"{db_count} signal(s) indexed in Astra DB. HuggingFace: {hf_status}\n\n"
         f"Ask about macro-level strategic decisions, regulatory timelines, "
         f"competitive positioning, or supply chain risks across the EU agricultural market.",
         role="assistant",
@@ -1183,7 +1183,7 @@ def _run_lens_search(topic: str | None, custom: str | None = None) -> html.Div:
         if total_signals == 0:
             return html.Div([
                 html.Div("○", className="empty-state-icon"),
-                html.Div("No signals in ChromaDB", className="empty-state-title"),
+                html.Div("No signals in Astra DB", className="empty-state-title"),
                 html.Div(
                     'Click "Run Scout Now" in the sidebar to ingest intelligence. '
                     "The Intelligence Lens will populate after the first scout cycle completes.",
@@ -1214,7 +1214,7 @@ def _run_lens_search(topic: str | None, custom: str | None = None) -> html.Div:
 
 
 def _tab_lens() -> html.Div:
-    """Strategic Intelligence Lens — semantic deep-dive via ChromaDB search."""
+    """Strategic Intelligence Lens — semantic deep-dive via Astra DB."""
     initial_results = _run_lens_search(_LENS_PRESETS[0])
 
     return html.Div([
@@ -1245,7 +1245,7 @@ def _tab_lens() -> html.Div:
             dbc.Col(html.Div([
                 html.Div("HOW IT WORKS", className="section-label"),
                 html.P(
-                    "ChromaDB semantic search surfaces the most relevant signals for any "
+                    "Astra DB semantic search surfaces the most relevant signals for any "
                     "macro-trend query. Results are ranked by cosine similarity using the "
                     "all-MiniLM-L6-v2 embedding model.",
                     style={"fontSize": "10.5px", "color": "#c4d0dc", "lineHeight": "1.7"},
@@ -1307,7 +1307,7 @@ def _llm_chat(question: str, context_signals: list[Signal]) -> str:
             f"  Content: {s.content}\n"
             f"  Source: {s.source_url}"
             for i, s in enumerate(context_signals, 1)
-        ) if context_signals else "No matching signals found in ChromaDB."
+        ) if context_signals else "No matching signals found in Astra DB."
     )
     try:
         from huggingface_hub import InferenceClient
@@ -1551,7 +1551,7 @@ def update_sidebar(_i: int, _n: int):
 
         html.Div([
             html.Div("SERVICES", className="sb-section-label"),
-            _dot("ChromaDB",   db_kind),
+            _dot("Astra DB",  db_kind),
             _dot("HuggingFace API", gem_kind),
             _dot("Scheduler",  sched_kind),
             _dot("Scout",      scout_kind),
@@ -1783,11 +1783,11 @@ if __name__ == "__main__":
 
     _scheduler_engine.start()
     stats = _db_stats()
-    log.info("App starting — ChromaDB: %d signals, HuggingFace: %s",
+    log.info("App starting — Astra DB: %d signals, HuggingFace: %s",
              stats["total"], "OK" if _HF_OK else "NO KEY")
 
     print(f"\n  Fendt Sentinel  ·  http://localhost:8050")
-    print(f"  ChromaDB : {stats['total']} signal(s)")
+    print(f"  Astra DB : {stats['total']} signal(s)")
     print(f"  HuggingFace: {'OK' if _HF_OK else 'no API key — set HUGGINGFACEHUB_API_TOKEN'}")
     print(f"  Scheduler: active (6-hour scout cycle)")
     print(f"  Auto-refresh: 30 seconds\n")

core/database.py

@@ -1,41 +1,53 @@
 """
-core/database.py — Fendt PESTEL-EL Sentinel: Vector Signal Store
-=================================================================
-Persistent ChromaDB collection backed by Pydantic-validated Signal models.
+core/database.py — Fendt PESTEL-EL Sentinel: Astra DB Vector Store
+===================================================================
+Production-grade serverless vector store backed by DataStax Astra DB.
+Embeddings are generated automatically via Astra Vectorize (Nvidia
+NV-Embed-QA, 1024 dims, cosine similarity) — no local GPU or API key
+overhead required at insert/query time.
 
 Architecture
 ------------
-  SignalDB             — thin façade: insert / query / delete
-  Signal               — canonical Pydantic v2 data model
+  SignalDB             — thin façade: insert / upsert / query / delete
+  Signal               — canonical Pydantic v2 data model (unchanged)
   PESTELDimension      — strict enum prevents tag drift
-  _build_document()    — deterministic text used for embedding
-  _to_signal()         — raw Chroma hit → validated Signal
-
-Embedding
----------
-  Uses ChromaDB's default embedding function (sentence-transformers
-  "all-MiniLM-L6-v2" via chroma's bundled `chromadb.utils.embedding_functions`).
-  No external API key required.
+  _build_document()    — deterministic text sent to Astra Vectorize
+  Signal._to_astra_doc()   — Signal → Astra document dict
+  Signal._from_astra_doc() — Astra document dict → Signal
+
+Similarity convention
+---------------------
+  Astra returns `$similarity` in [0.0, 1.0] (higher = more similar).
+  All existing call sites expect ChromaDB-style distance (lower = more
+  similar). SignalDB.search() converts: distance = 1.0 − similarity.
+
+Environment
+-----------
+  ASTRA_DB_TOKEN — Application token from Astra DB console (required)
 """
 
 from __future__ import annotations
 
 import json
+import os
 import uuid
 from datetime import datetime, timezone
 from enum import Enum
-from pathlib import Path
 from typing import Optional
 
-import chromadb
-from chromadb.utils import embedding_functions
+from astrapy import DataAPIClient
+from astrapy.constants import VectorMetric
+from astrapy.info import CollectionVectorServiceOptions
 from pydantic import BaseModel, Field, field_validator, model_validator
 
 # ─── Constants ────────────────────────────────────────────────────────────────
 
-_DB_DIR = Path(__file__).parent.parent / "data" / "chroma_db"
+_ASTRA_ENDPOINT  = "https://8debd070-7481-4ab4-bedd-3c06e680be00-us-east-2.apps.astra.datastax.com"
 _COLLECTION_NAME = "pestel_signals"
-_EMBED_MODEL = "all-MiniLM-L6-v2"   # fast, runs fully offline via ONNX
+
+# Astra Vectorize provider / model (no separate API key needed)
+_VECTORIZE_PROVIDER = "nvidia"
+_VECTORIZE_MODEL    = "NV-Embed-QA"
 
 
 # ─── Enums ────────────────────────────────────────────────────────────────────
@@ -103,20 +115,20 @@ class Signal(BaseModel):
 
     @model_validator(mode="after")
     def title_not_in_content(self) -> Signal:
-        # Soft sanity: content should be richer than just the title
         if self.content.strip() == self.title.strip():
             raise ValueError("content must differ from title")
         return self
 
-    # ── serialisation helpers ─────────────────────────────────────────────────
+    # ── graph-engine serialisation (JSON-safe flat dict) ─────────────────────
+    # Used by core/graph_engine.py LangGraph state — must stay stable.
 
     def to_metadata(self) -> dict:
-        """Flat dict safe for ChromaDB metadata (strings/ints/floats/bools only)."""
+        """Flat dict safe for LangGraph state (strings/ints/floats/bools only)."""
         return {
             "id":                self.id,
             "title":             self.title,
             "pestel_dimension":  self.pestel_dimension.value,
-            "content":           self.content,          # stored for lossless reconstruction
+            "content":           self.content,
             "source_url":        self.source_url,
             "impact_score":      self.impact_score,
             "novelty_score":     self.novelty_score,
@@ -129,7 +141,7 @@ class Signal(BaseModel):
 
     @classmethod
     def from_metadata(cls, metadata: dict) -> Signal:
-        """Reconstruct a Signal from a ChromaDB metadata dict."""
+        """Reconstruct a Signal from a to_metadata() dict (graph engine use)."""
         return cls(
             id=metadata["id"],
             title=metadata["title"],
@@ -144,15 +156,66 @@ class Signal(BaseModel):
             themes=json.loads(metadata.get("themes", "[]")),
         )
 
+    # ��─ Astra DB document serialisation ──────────────────────────────────────
 
-# ─── Embedding helper ─────────────────────────────────────────────────────────
+    def _to_astra_doc(self) -> dict:
+        """
+        Convert to an Astra DB document.
+
+        The ``$vectorize`` field is passed to Astra Vectorize (Nvidia
+        NV-Embed-QA) which generates the embedding server-side.
+        Entities and themes are stored as native lists (Astra supports
+        rich types; JSON-stringification is not required here).
+        """
+        return {
+            "_id":              self.id,
+            "$vectorize":       _build_document(self),
+            "title":            self.title,
+            "pestel_dimension": self.pestel_dimension.value,
+            "content":          self.content,
+            "source_url":       self.source_url,
+            "impact_score":     self.impact_score,
+            "novelty_score":    self.novelty_score,
+            "velocity_score":   self.velocity_score,
+            "disruption_score": self.disruption_score,
+            "date_ingested":    self.date_ingested.isoformat(),
+            "entities":         self.entities,
+            "themes":           self.themes,
+        }
+
+    @classmethod
+    def _from_astra_doc(cls, doc: dict) -> Signal:
+        """Reconstruct a Signal from an Astra DB document."""
+        entities = doc.get("entities") or []
+        themes   = doc.get("themes")   or []
+        # Accept both native lists and legacy JSON strings (migration safety)
+        if isinstance(entities, str):
+            entities = json.loads(entities)
+        if isinstance(themes, str):
+            themes = json.loads(themes)
+        return cls(
+            id=doc["_id"],
+            title=doc["title"],
+            pestel_dimension=PESTELDimension(doc["pestel_dimension"]),
+            content=doc["content"],
+            source_url=doc["source_url"],
+            impact_score=float(doc["impact_score"]),
+            novelty_score=float(doc["novelty_score"]),
+            velocity_score=float(doc["velocity_score"]),
+            date_ingested=datetime.fromisoformat(doc["date_ingested"]),
+            entities=entities,
+            themes=themes,
+        )
+
+
+# ─── Vectorize document builder ───────────────────────────────────────────────
 
 def _build_document(signal: Signal) -> str:
     """
-    Deterministic text fed to the embedding model.
+    Deterministic text sent to Astra Vectorize (Nvidia NV-Embed-QA).
 
-    Concatenates the semantically richest fields so that similarity search
-    works on both titles and full content.
+    Concatenates the semantically richest fields so similarity search
+    works across titles, content, entities, and themes.
     """
     parts = [
         f"[{signal.pestel_dimension.value}]",
@@ -170,7 +233,12 @@ def _build_document(signal: Signal) -> str:
 
 class SignalDB:
     """
-    Thin façade over a persistent ChromaDB collection.
+    Thin façade over an Astra DB collection with Astra Vectorize.
+
+    The collection is lazily created on first instantiation if it does
+    not yet exist. Embeddings are generated automatically by the Nvidia
+    NV-Embed-QA model hosted inside Astra — no local model or external
+    embedding API call is made by this class.
 
     Usage
     -----
@@ -179,44 +247,65 @@ class SignalDB:
     >>> results = db.search("EU tractor subsidies", n_results=5)
     """
 
-    def __init__(self, db_dir: Optional[Path] = None):
-        _DB_DIR.mkdir(parents=True, exist_ok=True)
-        path = str(db_dir or _DB_DIR)
-
-        self._client = chromadb.PersistentClient(path=path)
-        # DefaultEmbeddingFunction uses ONNX (all-MiniLM-L6-v2) —
-        # no PyTorch / GPU required; fully offline after first download.
-        self._ef = embedding_functions.DefaultEmbeddingFunction()
-        self._col = self._client.get_or_create_collection(
-            name=_COLLECTION_NAME,
-            embedding_function=self._ef,
-            metadata={"hnsw:space": "cosine"},
+    def __init__(self) -> None:
+        token = os.getenv("ASTRA_DB_TOKEN", "")
+        if not token:
+            raise RuntimeError(
+                "ASTRA_DB_TOKEN is not set. "
+                "Add it to your .env file and restart the app."
+            )
+
+        client    = DataAPIClient(token=token)
+        self._db  = client.get_database(_ASTRA_ENDPOINT)
+        self._col = self._get_or_create_collection()
+
+    # ── collection bootstrap ───────────────────────────────────────────────────
+
+    def _get_or_create_collection(self):
+        """Return the existing collection or create it with Astra Vectorize."""
+        existing_names = {c.name for c in self._db.list_collections()}
+        if _COLLECTION_NAME in existing_names:
+            return self._db.get_collection(_COLLECTION_NAME)
+
+        return self._db.create_collection(
+            _COLLECTION_NAME,
+            metric=VectorMetric.COSINE,
+            service=CollectionVectorServiceOptions(
+                provider=_VECTORIZE_PROVIDER,
+                model_name=_VECTORIZE_MODEL,
+            ),
         )
 
     # ── write ──────────────────────────────────────────────────────────────────
 
     def insert(self, signal: Signal) -> str:
         """
-        Insert or update a Signal (upsert by signal.id).
+        Upsert a Signal by its UUID.
+
+        Astra Vectorize auto-embeds the ``$vectorize`` field using
+        Nvidia NV-Embed-QA. No local embedding computation occurs.
 
         Returns the signal id.
         """
-        self._col.upsert(
-            ids=[signal.id],
-            documents=[_build_document(signal)],
-            metadatas=[signal.to_metadata()],
+        doc = signal._to_astra_doc()
+        self._col.find_one_and_replace(
+            {"_id": signal.id},
+            doc,
+            upsert=True,
         )
         return signal.id
 
     def insert_many(self, signals: list[Signal]) -> list[str]:
-        """Batch upsert. Returns list of ids."""
+        """
+        Batch upsert. Each signal is individually replaced/inserted so
+        Astra Vectorize can embed each ``$vectorize`` field.
+
+        Returns list of ids.
+        """
         if not signals:
             return []
-        self._col.upsert(
-            ids=[s.id for s in signals],
-            documents=[_build_document(s) for s in signals],
-            metadatas=[s.to_metadata() for s in signals],
-        )
+        for s in signals:
+            self.insert(s)
         return [s.id for s in signals]
 
     # ── read ───────────────────────────────────────────────────────────────────
@@ -228,7 +317,10 @@ class SignalDB:
         dimension_filter: Optional[PESTELDimension] = None,
     ) -> list[tuple[Signal, float]]:
         """
-        Semantic similarity search.
+        Semantic similarity search powered by Astra Vectorize.
+
+        The query string is embedded server-side using Nvidia NV-Embed-QA;
+        the top-k most similar signals are returned.
 
         Parameters
         ----------
@@ -239,52 +331,58 @@ class SignalDB:
         Returns
         -------
         List of (Signal, distance) tuples, sorted by distance ascending
-        (lower = more similar).
+        (lower = more similar).  Distance = 1.0 − Astra similarity score,
+        preserving the ChromaDB convention used throughout the codebase.
         """
-        where = (
-            {"pestel_dimension": dimension_filter.value}
-            if dimension_filter
-            else None
-        )
-        kwargs: dict = dict(
-            query_texts=[query],
-            n_results=min(n_results, self._col.count() or 1),
-            include=["documents", "metadatas", "distances"],
+        filter_: dict = {}
+        if dimension_filter:
+            filter_["pestel_dimension"] = dimension_filter.value
+
+        cursor = self._col.find(
+            filter_,
+            sort={"$vectorize": query},
+            limit=n_results,
+            include_similarity=True,
+            projection={"$vector": False},   # omit raw embedding bytes
         )
-        if where:
-            kwargs["where"] = where
-
-        raw = self._col.query(**kwargs)
 
         results: list[tuple[Signal, float]] = []
-        for doc, meta, dist in zip(
-            raw["documents"][0],
-            raw["metadatas"][0],
-            raw["distances"][0],
-        ):
-            sig = Signal.from_metadata(meta)
-            results.append((sig, round(dist, 4)))
+        for doc in cursor:
+            similarity = float(doc.pop("$similarity", 0.0))
+            distance   = round(1.0 - similarity, 4)
+            sig        = Signal._from_astra_doc(doc)
+            results.append((sig, distance))
         return results
 
     def get_by_id(self, signal_id: str) -> Optional[Signal]:
         """Exact fetch by UUID."""
-        raw = self._col.get(
-            ids=[signal_id],
-            include=["documents", "metadatas"],
+        doc = self._col.find_one(
+            {"_id": signal_id},
+            projection={"$vector": False},
         )
-        if not raw["ids"]:
+        if doc is None:
             return None
-        return Signal.from_metadata(raw["metadatas"][0])
+        return Signal._from_astra_doc(doc)
 
     def get_all(self) -> list[Signal]:
-        """Return every signal in the collection."""
-        raw = self._col.get(include=["documents", "metadatas"])
-        return [Signal.from_metadata(m) for m in raw["metadatas"]]
+        """
+        Return every signal in the collection (up to 2 000).
+
+        For dashboard and export use. Signals are returned in arbitrary
+        order; callers are responsible for sorting.
+        """
+        cursor = self._col.find(
+            {},
+            projection={"$vector": False},
+            limit=2_000,
+        )
+        return [Signal._from_astra_doc(doc) for doc in cursor]
 
     # ── stats ──────────────────────────────────────────────────────────────────
 
     def count(self) -> int:
-        return self._col.count()
+        """Fast estimated document count (no full scan)."""
+        return self._col.count_documents({}, upper_bound=10_000)
 
     def stats(self) -> dict:
         all_signals = self.get_all()
@@ -293,21 +391,18 @@ class SignalDB:
             by_dim[s.pestel_dimension.value] = by_dim.get(s.pestel_dimension.value, 0) + 1
         return {
             "total_signals": self.count(),
-            "by_dimension": by_dim,
-            "collection": _COLLECTION_NAME,
-            "db_path": str(_DB_DIR),
+            "by_dimension":  by_dim,
+            "collection":    _COLLECTION_NAME,
+            "endpoint":      _ASTRA_ENDPOINT,
+            "vectorize":     f"{_VECTORIZE_PROVIDER}/{_VECTORIZE_MODEL}",
         }
 
     # ── delete ─────────────────────────────────────────────────────────────────
 
     def delete(self, signal_id: str) -> None:
-        self._col.delete(ids=[signal_id])
+        self._col.delete_one({"_id": signal_id})
 
     def clear(self) -> None:
-        """Wipe the collection. Use with caution."""
-        self._client.delete_collection(_COLLECTION_NAME)
-        self._col = self._client.get_or_create_collection(
-            name=_COLLECTION_NAME,
-            embedding_function=self._ef,
-            metadata={"hnsw:space": "cosine"},
-        )
+        """Drop and recreate the collection. Use with caution."""
+        self._db.drop_collection(_COLLECTION_NAME)
+        self._col = self._get_or_create_collection()

core/graph_engine.py

@@ -7,7 +7,7 @@ Flow
 ----
   Signal
     → [Node 1] receive_signal  : validates & wraps input state
-    → [Node 2] rag_query       : fetches top-2 semantically related signals from ChromaDB
+    → [Node 2] rag_query       : fetches top-2 semantically related signals from Astra DB
     → [Node 3] identify_edges  : asks HuggingFace model to name relationships
     → [Node 4] update_graph    : appends nodes/edges to data/graph.json
 

core/logger.py

@@ -6,7 +6,7 @@ Usage:
     log = get_logger(__name__)
     log.info("Pipeline started")
     log.warning("Gemini quota low")
-    log.error("ChromaDB unreachable: %s", exc)
+    log.error("Astra DB unreachable: %s", exc)
 
 All log records go to:
   - logs/agent.log  (rotating, 5 MB × 3 backups, always)
@@ -64,7 +64,8 @@ def _configure_root() -> None:
 
     # Silence noisy third-party loggers
     for noisy in ("werkzeug", "dash", "dash.dash", "httpx",
-                  "urllib3", "chromadb", "apscheduler.executors"):
+                  "urllib3", "astrapy", "httpcore",
+                  "apscheduler.executors"):
         logging.getLogger(noisy).setLevel(logging.WARNING)
 
 

core/pipeline.py

@@ -2,7 +2,7 @@
 core/pipeline.py — Fendt PESTEL-EL Sentinel: Scoring Pipeline
 ==============================================================
 Takes raw text (news article, report snippet, any string) and
-returns a fully-validated Signal ready for ChromaDB insertion.
+returns a fully-validated Signal ready for Astra DB insertion.
 
 Flow
 ----
@@ -13,7 +13,7 @@ Flow
 Public API
 ----------
   score_text(text)        → Signal
-  score_and_save(text, db) → Signal   (also persists to ChromaDB)
+  score_and_save(text, db) → Signal   (also persists to Astra DB)
 """
 
 from __future__ import annotations
@@ -183,7 +183,7 @@ _DEDUP_THRESHOLD = 0.08   # cosine distance; lower = more similar. Tune here.
 
 def _is_duplicate(text: str, db: SignalDB) -> bool:
     """
-    Return True if ChromaDB already contains a semantically near-identical document.
+    Return True if Astra DB already contains a semantically near-identical document.
 
     Uses cosine distance from ChromaDB (range 0–2, lower = more similar).
     A threshold of 0.08 catches rephrased duplicates of the same article
@@ -301,7 +301,7 @@ def score_and_save(
     text: str, db: Optional[SignalDB] = None
 ) -> Optional[tuple[Signal, LLMScoreResponse]]:
     """
-    Score text and persist to ChromaDB.
+    Score text and persist to Astra DB.
 
     Returns None if the text is a near-duplicate of an existing signal.
     Returns (Signal, LLMScoreResponse) otherwise.

core/scheduler.py

@@ -9,7 +9,7 @@ Architecture
     → every 6 hours: _run_scout_cycle()
         → scrape each PESTEL_SOURCE
         → score each article via Gemini
-        → save to ChromaDB
+        → save to Astra DB
     → every 30 seconds: _heartbeat()
         → update HEALTH dict (alive, last_run, counts)
 
@@ -69,7 +69,7 @@ HEALTH: dict = {
 def _run_scout_cycle() -> None:
     """
     One full intelligence cycle:
-      scrape all sources → score via Gemini → save to ChromaDB.
+      scrape all sources → score via Gemini → save to Astra DB.
     Errors per source are caught; they never abort the full cycle.
     """
     from core.scraper  import scrape_source

requirements.txt

@@ -82,6 +82,8 @@ zipp==3.23.0
 # ── Added for Tab 6 export formats ──────────────────────────────────────────
 openpyxl>=3.1.0
 python-docx>=0.8.11
+# ── Vector store (Astra DB + Astra Vectorize) ────────────────────────────────
+astrapy>=1.5.0
 # ── AI / LLM stack (HuggingFace + LangChain) ────────────────────────────────
 langchain>=0.3.0,<0.4
 langchain-huggingface>=0.1.0,<0.2