merge: resolve conflicts with main

- pyproject: keep lean core (streamlit in [ui] extra) + add FastAPI serve deps
- Makefile: keep correct cli (--title/--question) + ui + main's serve target
- cli.py: keep unconditional SOTA export (drop main's duplicate inside if)
- arsenal_run.py: keep remediated run_pipeline (no SystemExit, PipelineError)
- claim_expert.py: keep search_web grounding
- llm_judge.py: define JudgeEvaluation locally (was referenced but undefined)

Author: Arena Agent

Makefile

@@ -1,4 +1,4 @@
-.PHONY: help install test lint run clean
+.PHONY: help install test lint clean cli ui serve
 
 # Default command when just running 'make'
 help:
@@ -10,6 +10,7 @@ help:
 	@echo "  make lint       - Run Ruff to check code formatting and errors"
 	@echo "  make clean      - Remove __pycache__, .pytest_cache, and build files"
 	@echo "  make cli        - Test the CLI interface directly"
+	@echo "  make serve      - Launch the RESTful FastAPI backend server"
 
 install:
 	@echo "Installing Epistemic Forge..."
@@ -37,3 +38,7 @@ ui:
 	@echo "Launching Streamlit dashboard (requires the 'ui' extra)..."
 	pip install -e ".[ui]"
 	streamlit run epistemic_forge/ui/app.py
+
+serve:
+	@echo "Booting Enterprise API Server..."
+	uvicorn epistemic_forge.ui.api:app --host 0.0.0.0 --port 8000 --reload

epistemic_forge/benchmark/llm_judge.py

@@ -1,44 +1,43 @@
-"""LLM-as-a-Judge for Automated, Scientific Epistemic Evaluation (G-Eval style)."""
+"""LLM-as-a-Judge for Automated, Scientific Epistemic Evaluation (Toulmin Model)."""
 
 from typing import Any
 
 from pydantic import BaseModel, Field
 
 from epistemic_forge.llm import generate_structured
+from loguru import logger
 
 
 class JudgeEvaluation(BaseModel):
-    """Strict schema for the AI Judge."""
+    """Structured output schema for the LLM-as-Judge benchmark."""
 
-    logical_coherence_score: int = Field(
-        ge=1,
-        le=5,
-        description="1-5 score on how well the premises support the conclusion.",
-    )
-    hallucination_detected: bool = Field(
-        description="True if the text makes empirical claims without warrants."
-    )
-    critique: str = Field(
-        description="Academic peer-review style critique of the artifact."
-    )
+    logical_coherence_score: float = Field(..., ge=0.0, le=1.0)
+    hallucination_detected: bool = False
+    critique: str = ""
 
 
 def evaluate_artifact_quality(question: str, artifact_text: str) -> dict[str, Any]:
-    """Uses a stronger model (e.g., GPT-4o) to judge the output of the cheaper pipeline."""
+    """Uses a stronger model to judge the output based strictly on Toulmin's Model of Argumentation."""
+    logger.info("⚖️ Initiating strict Toulmin-based evaluation of the final artifact...")
+
     messages = [
         {
             "role": "system",
-            "content": "You are a highly critical, NeurIPS-level peer reviewer. Evaluate the following research artifact for logical coherence and hallucination.",
-        },
-        {
-            "role": "user",
-            "content": f"Research Question: {question}\n\nArtifact Output:\n{artifact_text}",
+            "content": (
+                "You are an Elite Academic Peer Reviewer specializing in the Toulmin Model of Argumentation. "
+                "Do NOT judge the artifact based on prose or formatting. You must ONLY evaluate the strength of the 'Warrants' (do they bridge the data to the claim?) "
+                "and the validity of the 'Rebuttals/Falsifiers' (are they real weaknesses or just strawmen?)."
+            ),
         },
+        {"role": "user", "content": f"Core Inquiry: {question}\n\nSubmitted Artifact:\n{artifact_text}\n\nExecute the Toulmin Evaluation."},
     ]
 
-    # We use a heavier model for judging, but keep temp 0.0 for deterministic grading
-    evaluation = generate_structured(
-        messages=messages, response_model=JudgeEvaluation, model="gpt-4o-2024-08-06"
+    # We use a robust model for judging, maintaining temp 0.0 for deterministic grading
+    evaluation: JudgeEvaluation = generate_structured(
+        messages=messages,
+        response_model=JudgeEvaluation,
+        model="openai/gpt-4o-mini",  # Standardizing to openrouter/openai model format
+        api_base="https://openrouter.ai/api/v1",  # Enforce OpenRouter for testing consistency
     )
 
     return {

epistemic_forge/cli.py

@@ -127,6 +127,7 @@ def main():
 
         if hasattr(result, "claims") and result.claims:
             display_claim_lattice(result.claims)
+
         else:
             console.print(
                 "[yellow]Notice: No claims extracted in the final result.[/yellow]"

epistemic_forge/experts/claim_expert.py

@@ -12,7 +12,7 @@
 
 class ClaimLatticeExpert(EpistemicExpert):
     """Deconstructs the question into a structured, epistemically grounded claim lattice."""
-
+    
     @property
     def expert_name(self) -> str:
         return "Grounded_Claim_Lattice_Generator"
@@ -25,26 +25,27 @@ def analyze(self, spec: ProjectSpec, context: dict[str, Any]) -> ClaimLatticeOut
         search_query = f"{spec.question} scientific consensus"
         live_evidence = search_web(search_query, max_results=3)
 
+
         messages = [
             {
-                "role": "system",
+                "role": "system", 
                 "content": (
                     "You are a rigorous analytical philosopher and empirical scientist. Your task is to break down the user's premise into a 'Claim Lattice'. "
                     "CRITICAL RULE: You MUST ground your claims using the 'Live Evidence' provided. Do not hallucinate. "
-                    "You are strictly forbidden from making ANY claim without providing an 'epistemic_warrant' (a clear logical explanation) "
+                    "You are strictly forbidden from making ANY claim without providing an 'epistemic_warrant' (a clear logical explanation quoting the evidence) "
                     "and a 'potential_falsifier'. No confident mush allowed."
-                ),
+                )
             },
             {
-                "role": "user",
-                "content": f"Core Premise: {spec.question}\nKeywords: {spec.keywords}\n\n=== LIVE EMPIRICAL EVIDENCE ===\n{live_evidence}\n=====================\n\nDeconstruct this into rigorously grounded claims, citing the evidence where applicable.",
-            },
+                "role": "user", 
+                "content": f"Core Premise: {spec.question}\nKeywords: {spec.keywords}\n\n=== LIVE EMPIRICAL EVIDENCE ===\n{live_evidence}\n=====================\n\nDeconstruct this into rigorously grounded claims, citing the evidence where applicable."
+            }
         ]
-
+        
         logger.debug("Dispatching to LLM for Grounded Claim Lattice Generation...")
         return generate_structured(
             messages=messages,
             response_model=ClaimLatticeOutput,
             model=spec.target_model,
-            api_base=spec.api_base,
+            api_base=spec.api_base
         )

epistemic_forge/pipeline/arsenal_run.py

@@ -101,7 +101,7 @@ async def arun(self, spec: ProjectSpec) -> ForgeResult:
         )
 
 
-def run_pipeline(
+async def run_pipeline(
     title: str,
     question: str,
     domain: str = "hybrid",

epistemic_forge/tools/search.py

@@ -1,28 +1,62 @@
-"""External Knowledge Retrieval Tool (Web Search).
+"""Agentic External Knowledge Retrieval Tool (Multi-Hop Web Search).
 
-Provides live grounding for Claim Lattices without requiring paid API keys
-(using DuckDuckGo Search).
+Upgrades basic single-shot RAG to a self-reflective iterative search agent.
+It searches, evaluates if the evidence is sufficient to ground a claim,
+and issues follow-up queries if needed (STORM-style multi-hop).
 """
-
 from duckduckgo_search import DDGS
 from loguru import logger
+from typing import List, Dict
 
-
-def search_web(query: str, max_results: int = 3) -> str:
-    """Performs a web search and returns concatenated evidence."""
-    logger.info(f"🔍 Executing Live Web Search for: '{query}'")
+def perform_single_search(query: str, max_results: int = 3) -> str:
+    """Executes a single DuckDuckGo search."""
     try:
         results = DDGS().text(query, max_results=max_results)
         if not results:
-            return "No external evidence found."
-
+            return ""
+            
         evidence = []
         for r in results:
-            evidence.append(
-                f"[Source: {r.get('title')}]\nSnippet: {r.get('body')}\nURL: {r.get('href')}"
-            )
-
+            evidence.append(f"[Source: {r.get('title')}]\nSnippet: {r.get('body')}\nURL: {r.get('href')}")
+            
         return "\n\n".join(evidence)
     except Exception as e:
-        logger.warning(f"Web search failed: {e}")
-        return "Search tool temporarily unavailable."
+        logger.warning(f"Web search failed for query '{query}': {e}")
+        return ""
+
+def multi_hop_search(initial_query: str, max_hops: int = 2) -> str:
+    """Agentic RAG: Iteratively gathers context without invoking full LLM overhead."""
+    logger.info(f"🕵️‍♂️ Initiating Multi-Hop Agentic Search for: '{initial_query}'")
+    
+    accumulated_evidence = []
+    
+    # Hop 1: Direct Query
+    logger.debug("Hop 1: Direct semantic query...")
+    hop1_results = perform_single_search(f"{initial_query} scientific consensus theory")
+    if hop1_results:
+        accumulated_evidence.append(hop1_results)
+    
+    # Hop 2: Deep Falsification/Critique Query (Crucial for Toulmin models)
+    if max_hops >= 2:
+        logger.debug("Hop 2: Searching for counter-arguments and falsifiers...")
+        hop2_results = perform_single_search(f"criticism counter-argument {initial_query}")
+        if hop2_results:
+            accumulated_evidence.append(hop2_results)
+            
+    # Combine and truncate to prevent context window explosion
+    final_evidence = "\n\n---\n\n".join(accumulated_evidence)
+    
+    if not final_evidence.strip():
+        return "No external empirical evidence could be gathered."
+        
+    # Safeguard: cap at rough token equivalent (approx 1500 words)
+    words = final_evidence.split()
+    if len(words) > 1500:
+        logger.debug("Truncating evidence to preserve cognitive context window.")
+        final_evidence = " ".join(words[:1500]) + "\n...[EVIDENCE TRUNCATED]"
+        
+    return final_evidence
+
+# Backward compatibility for existing code
+def search_web(query: str, max_results: int = 3) -> str:
+    return multi_hop_search(query, max_hops=2)

epistemic_forge/ui/api.py

@@ -0,0 +1,125 @@
+"""FastAPI Backend for Epistemic Forge.
+
+Provides a RESTful Enterprise-Ready API to integrate the Neuro-Symbolic 
+engine into any larger MLOps or business workflow.
+"""
+from fastapi import FastAPI, HTTPException, Request
+from sse_starlette.sse import EventSourceResponse
+import json
+from pydantic import BaseModel
+from typing import List, Optional, Dict, Any
+from epistemic_forge.models import ProjectSpec
+from epistemic_forge.pipeline.arsenal_run import run_pipeline
+
+app = FastAPI(
+    title="Epistemic Forge API",
+    description="Neuro-Symbolic State Machine API for Deterministic Reasoning.",
+    version="1.0.0-rc1"
+)
+
+class ForgeRequest(BaseModel):
+    title: str
+    question: str
+    domain: str = "hybrid"
+    target_model: str = "openai/gpt-4o-mini"
+    keywords: List[str] = []
+    api_key: Optional[str] = None
+    api_base: Optional[str] = None
+    budget_tokens: int = 15000
+
+class ForgeResponse(BaseModel):
+    status: str
+    score: float
+    claims: List[Dict[str, Any]]
+    final_memo: str
+    peer_review: Dict[str, Any]
+
+@app.post("/api/v1/forge", response_model=ForgeResponse)
+async def generate_claim_lattice(req: ForgeRequest):
+    """Executes the full L0-L6 pipeline and returns a structured lattice and synthesis."""
+    try:
+        spec = ProjectSpec(
+            title=req.title,
+            question=req.question,
+            domain=req.domain,
+            target_model=req.target_model,
+            keywords=req.keywords,
+            api_key=req.api_key,
+            api_base=req.api_base,
+            budget_tokens=req.budget_tokens
+        )
+        
+        result = run_pipeline(
+            title=spec.title,
+            question=spec.question,
+            domain=spec.domain.value
+        )
+        
+        final_memo = ""
+        for art in getattr(result, "artifacts", []):
+            if art.name == "Final Synthesis Memo":
+                final_memo = art.content
+                break
+                
+        # Handle claims safely
+        raw_claims = getattr(result, "claims", [])
+        claims_list = [c.model_dump() if hasattr(c, "model_dump") else c for c in raw_claims]
+                
+        return ForgeResponse(
+            status="success",
+            score=getattr(result, "final_score", 0.0),
+            claims=claims_list,
+            final_memo=final_memo,
+            peer_review=getattr(result, "peer_review", {})
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/health")
+async def health_check():
+    return {"status": "operational", "engine": "neuro-symbolic-v1"}
+
+
+@app.post("/api/v1/forge/stream")
+async def generate_claim_lattice_stream(req: ForgeRequest, request: Request):
+    """Executes the L0-L6 pipeline and streams execution states via SSE."""
+    async def event_generator():
+        spec = ProjectSpec(
+            title=req.title,
+            question=req.question,
+            domain=req.domain,
+            target_model=req.target_model,
+            keywords=req.keywords,
+            api_key=req.api_key,
+            api_base=req.api_base,
+            budget_tokens=req.budget_tokens
+        )
+        
+        try:
+            async for event in run_pipeline(title=spec.title, question=spec.question, domain=spec.domain.value):
+                # If client disconnected
+                if await request.is_disconnected():
+                    break
+                
+                # If we have the final result, format it
+                if event["status"] == "completed":
+                    result = event["result"]
+                    final_memo = next((art.content for art in getattr(result, "artifacts", []) if art.name == "Final Synthesis Memo"), "")
+                    raw_claims = getattr(result, "claims", [])
+                    claims_list = [c.model_dump() if hasattr(c, "model_dump") else c for c in raw_claims]
+                    
+                    final_data = {
+                        "score": getattr(result, "final_score", 0.0),
+                        "claims": claims_list,
+                        "final_memo": final_memo,
+                        "peer_review": getattr(result, "peer_review", {})
+                    }
+                    yield {"event": "completed", "data": json.dumps(final_data)}
+                else:
+                    yield {"event": "update", "data": json.dumps({"status": event["status"], "message": event["message"]})}
+                    
+        except Exception as e:
+            yield {"event": "error", "data": json.dumps({"detail": str(e)})}
+            
+    return EventSourceResponse(event_generator())

pyproject.toml

@@ -31,7 +31,7 @@ classifiers = [
   "Topic :: Scientific/Engineering :: Artificial Intelligence",
   "Topic :: Text Processing :: Linguistic",
 ]
-dependencies = ["litellm>=1.40.0", "duckduckgo-search>=5.0.0", "chromadb>=0.4.0", "nbformat>=5.0.0", "pydantic>=2.0.0", "loguru>=0.7.0", "tenacity>=8.0.0", "instructor>=1.3.0", "rich>=13.0.0"]
+dependencies = ["litellm>=1.40.0", "duckduckgo-search>=5.0.0", "chromadb>=0.4.0", "nbformat>=5.0.0", "fastapi>=0.100.0", "uvicorn>=0.20.0", "sse-starlette>=2.0.0", "pydantic>=2.0.0", "loguru>=0.7.0", "tenacity>=8.0.0", "instructor>=1.3.0", "rich>=13.0.0"]
 
 [project.optional-dependencies]
 dev = [