Update genesis/providers.py

genesis/providers.py

@@ -1,133 +1,55 @@
-from __future__ import annotations
-
+# genesis/graphdb.py
 import os
-import asyncio
-from typing import List, Tuple
-
-import httpx
-
-# Optional: Gemini and DeepSeek post-processors to polish final text ONLY.
-# They must never add wet-lab protocols or operational steps.
-
-
-async def gemini_postprocess(text: str, citations: List[dict]) -> str:
-    """
-    Polish for clarity/flow using Gemini (sync SDK wrapped in a thread).
-    Falls back to original text if not configured or on error.
-    """
-    api_key = os.getenv("GEMINI_API_KEY")
-    if not api_key:
-        return text
-
-    try:
-        import google.generativeai as genai
-
-        genai.configure(api_key=api_key)
-        model = genai.GenerativeModel("gemini-1.5-flash")
-
-        prompt = (
-            "Polish the following high-level scientific synthesis for clarity and flow. "
-            "Do NOT add wet-lab procedures or any operational/step-by-step details. "
-            "Preserve factual claims and cautious tone.\n\n"
-            f"{text}"
-        )
+from typing import List, Dict
+from neo4j import GraphDatabase
 
-        def _call_sync() -> str:
-            resp = model.generate_content(prompt)
-            return getattr(resp, "text", None) or text
+NEO4J_URI = os.getenv("NEO4J_URI")
+NEO4J_USER = os.getenv("NEO4J_USER")
+NEO4J_PASSWORD = os.getenv("NEO4J_PASSWORD")
 
-        return await asyncio.to_thread(_call_sync)
-
-    except Exception:
-        return text
-
-
-async def deepseek_postprocess(text: str, citations: List[dict]) -> str:
-    """
-    Polish using a generic OpenAI-compatible DeepSeek endpoint.
-    Configure DEEPSEEK_BASE_URL and DEEPSEEK_API_KEY (and optionally DEEPSEEK_MODEL).
-    """
-    base = os.getenv("DEEPSEEK_BASE_URL")
-    key = os.getenv("DEEPSEEK_API_KEY")
-    if not base or not key:
-        return text
+def _get_driver():
+    if not (NEO4J_URI and NEO4J_USER and NEO4J_PASSWORD):
+        raise ValueError("[GraphDB] Missing Neo4j credentials.")
+    return GraphDatabase.driver(NEO4J_URI, auth=(NEO4J_USER, NEO4J_PASSWORD))
 
+def write_topic_and_papers(topic: str, citations: List[Dict], expanded_terms: List[str]):
+    """Write topic, papers, and related concepts to Neo4j."""
     try:
-        async with httpx.AsyncClient(timeout=60.0) as http:
-            r = await http.post(
-                f"{base.rstrip('/')}/v1/chat/completions",
-                headers={
-                    "Authorization": f"Bearer {key}",
-                    "Content-Type": "application/json",
-                },
-                json={
-                    "model": os.getenv("DEEPSEEK_MODEL", "deepseek-chat"),
-                    "messages": [
-                        {
-                            "role": "system",
-                            "content": (
-                                "You are a scientific editor. Improve structure and clarity only. "
-                                "Never add wet-lab protocols, experimental steps, or operational advice."
-                            ),
-                        },
-                        {
-                            "role": "user",
-                            "content": (
-                                "Polish the following high-level synthesis without adding operational details.\n\n"
-                                f"{text}"
-                            ),
-                        },
-                    ],
-                    "temperature": 0.3,
-                },
+        driver = _get_driver()
+        with driver.session() as session:
+            # Create Topic node
+            session.run(
+                "MERGE (t:Topic {name: $name})",
+                name=topic
             )
-            data = r.json()
-            return (
-                data.get("choices", [{}])[0]
-                .get("message", {})
-                .get("content", text)
-            )
-    except Exception:
-        return text
-
-
-async def postprocess_summary(base_text: str, citations: List[dict], engine: str = "none") -> str:
-    """
-    Dispatch to the chosen post-processor (none|gemini|deepseek).
-    Always returns safe, high-level text.
-    """
-    engine = (engine or "none").lower()
-    if engine == "gemini":
-        return await gemini_postprocess(base_text, citations)
-    if engine == "deepseek":
-        return await deepseek_postprocess(base_text, citations)
-    return base_text
-
-
-async def synthesize_tts(text: str) -> Tuple[bytes | None, str]:
-    """
-    ElevenLabs TTS → (audio_bytes, mime). Returns (None, "") if not configured.
-    Requires ELEVEN_LABS_API_KEY and optional ELEVEN_LABS_VOICE_ID.
-    """
-    key = os.getenv("ELEVEN_LABS_API_KEY")
-    voice_id = os.getenv("ELEVEN_LABS_VOICE_ID", "21m00Tcm4TlvDq8ikWAM")
-    if not key:
-        return None, ""
-
-    payload = {
-        "text": text[:6000],  # safety limit
-        "model_id": "eleven_multilingual_v2",
-        "voice_settings": {"stability": 0.5, "similarity_boost": 0.75},
-    }
 
-    url = f"https://api.elevenlabs.io/v1/text-to-speech/{voice_id}"
-    async with httpx.AsyncClient(timeout=120.0) as http:
-        r = await http.post(
-            url,
-            headers={"xi-api-key": key, "Accept": "audio/mpeg"},
-            json=payload,
-        )
-        if r.status_code >= 400:
-            # Propagate a readable error to the UI layer
-            raise RuntimeError(f"TTS API error {r.status_code}: {r.text[:200]}")
-        return r.content, r.headers.get("content-type", "audio/mpeg")
+            # Create Paper nodes and relationships
+            for cite in citations:
+                paper_id = cite.get("id", cite.get("url", ""))
+                session.run(
+                    """
+                    MERGE (p:Paper {id: $id, url: $url})
+                    ON CREATE SET p.type = $type
+                    MERGE (t:Topic {name: $topic})
+                    MERGE (t)-[:RELATED_TO]->(p)
+                    """,
+                    id=paper_id,
+                    url=cite.get("url"),
+                    type=cite.get("type"),
+                    topic=topic
+                )
+
+            # Create Concept nodes and relationships
+            for term in expanded_terms:
+                session.run(
+                    """
+                    MERGE (c:Concept {name: $term})
+                    MERGE (t:Topic {name: $topic})
+                    MERGE (t)-[:HAS_CONCEPT]->(c)
+                    """,
+                    term=term,
+                    topic=topic
+                )
+        driver.close()
+    except Exception as e:
+        print(f"[GraphDB] Failed to write data: {e}")