longparser 0.1.0__py3-none-any.whl

longparser/server/chat/llm_chain.py

@@ -0,0 +1,153 @@
+"""LangChain LLM abstraction for LongParser Chat.
+
+Replaces custom llm_router.py with LangChain's provider-specific chat models.
+Supports: OpenAI, Gemini, Groq, OpenRouter.
+Includes: with_structured_output, with_retry.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+from typing import Optional
+
+from .schemas import ChatConfig
+
+logger = logging.getLogger(__name__)
+
+
+# Default models per provider (updated Feb 2026)
+DEFAULT_MODELS: dict[str, str] = {
+    "openai": "gpt-5.3-codex",
+    "gemini": "gemini-2.5-flash",
+    "groq": "openai/gpt-oss-120b",
+    "openrouter": "openai/gpt-5.3-codex",
+}
+
+
+def _create_openai(model: str, temperature: float, max_tokens: int,
+                   max_retries: int, callbacks: Optional[list] = None):
+    """Create OpenAI chat model."""
+    from langchain_openai import ChatOpenAI
+    return ChatOpenAI(
+        model=model,
+        temperature=temperature,
+        max_tokens=max_tokens,
+        max_retries=max_retries,
+        callbacks=callbacks or [],
+    )
+
+
+def _create_gemini(model: str, temperature: float, max_tokens: int,
+                   max_retries: int, callbacks: Optional[list] = None):
+    """Create Google Gemini chat model."""
+    from langchain_google_genai import ChatGoogleGenerativeAI
+    return ChatGoogleGenerativeAI(
+        model=model,
+        temperature=temperature,
+        max_output_tokens=max_tokens,
+        max_retries=max_retries,
+        callbacks=callbacks or [],
+    )
+
+
+def _create_groq(model: str, temperature: float, max_tokens: int,
+                 max_retries: int, callbacks: Optional[list] = None):
+    """Create Groq chat model."""
+    from langchain_groq import ChatGroq
+    return ChatGroq(
+        model=model,
+        temperature=temperature,
+        max_tokens=max_tokens,
+        max_retries=max_retries,
+        callbacks=callbacks or [],
+    )
+
+
+def _create_openrouter(model: str, temperature: float, max_tokens: int,
+                       max_retries: int, callbacks: Optional[list] = None):
+    """Create OpenRouter chat model (OpenAI-compatible)."""
+    from langchain_openai import ChatOpenAI
+    return ChatOpenAI(
+        model=model,
+        temperature=temperature,
+        max_tokens=max_tokens,
+        max_retries=max_retries,
+        base_url="https://openrouter.ai/api/v1",
+        api_key=os.getenv("OPENROUTER_API_KEY", ""),
+        callbacks=callbacks or [],
+    )
+
+
+_CREATORS = {
+    "openai": _create_openai,
+    "gemini": _create_gemini,
+    "groq": _create_groq,
+    "openrouter": _create_openrouter,
+}
+
+
+def get_chat_model(
+    provider: Optional[str] = None,
+    model: Optional[str] = None,
+    config: Optional[ChatConfig] = None,
+    *,
+    temperature: float = 0.1,
+    max_tokens: Optional[int] = None,
+    json_mode: bool = False,
+    callbacks: Optional[list] = None,
+):
+    """Create a LangChain chat model for any supported provider.
+
+    Args:
+        provider: LLM provider name (openai, gemini, groq, openrouter).
+        model: Model name. If None, uses config or provider default.
+        config: ChatConfig for defaults and reliability settings.
+        temperature: Sampling temperature.
+        max_tokens: Max output tokens.
+        json_mode: If True, wraps with .with_structured_output(LLMAnswer).
+        callbacks: Optional LangChain callback handlers.
+
+    Returns:
+        A LangChain BaseChatModel (or structured output wrapper).
+    """
+    config = config or ChatConfig()
+    provider = provider or config.llm_provider
+    model = model or config.llm_model or DEFAULT_MODELS.get(provider, "gpt-4o")
+    max_tokens = max_tokens or config.max_output_tokens
+
+    creator = _CREATORS.get(provider)
+    if not creator:
+        raise ValueError(
+            f"Unknown LLM provider: {provider}. "
+            f"Supported: {', '.join(_CREATORS)}"
+        )
+
+    llm = creator(
+        model=model,
+        temperature=temperature,
+        max_tokens=max_tokens,
+        max_retries=config.llm_max_retries,
+        callbacks=callbacks,
+    )
+
+    # Structured output: returns Pydantic LLMAnswer directly
+    if json_mode:
+        from .schemas import LLMAnswer
+        llm = llm.with_structured_output(LLMAnswer)
+
+    return llm
+
+
+def get_plain_chat_model(
+    provider: Optional[str] = None,
+    model: Optional[str] = None,
+    config: Optional[ChatConfig] = None,
+):
+    """Get a plain (non-structured) chat model for summarization / plain text tasks."""
+    return get_chat_model(
+        provider=provider,
+        model=model,
+        config=config,
+        json_mode=False,
+    )

longparser/server/chat/retriever.py

@@ -0,0 +1,111 @@
+"""LangChain retriever for LongParser Chat.
+
+Wraps existing vector store + embeddings as a LangChain BaseRetriever,
+enabling plugging into LCEL chains.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+from langchain_core.callbacks import CallbackManagerForRetrieverRun
+from langchain_core.documents import Document
+from langchain_core.retrievers import BaseRetriever
+from pydantic import Field
+
+logger = logging.getLogger(__name__)
+
+
+class LongParserRetriever(BaseRetriever):
+    """LangChain retriever backed by LongParser's existing vector store infra.
+
+    Connects to the same Chroma/FAISS/Qdrant indexes built by the embed pipeline.
+    Uses LangChain-native embeddings for query encoding.
+    """
+
+    db: Any = Field(exclude=True)
+    tenant_id: str
+    job_id: str
+    top_k: int = 5
+
+    # Resolved at runtime from index_version
+    _vector_db: Optional[str] = None
+    _model_name: Optional[str] = None
+    _provider: Optional[str] = None
+    _configured_dimensions: Optional[int] = None
+    _collection: Optional[str] = None
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    async def _resolve_index(self) -> None:
+        """Load index metadata from MongoDB (lazy, once)."""
+        if self._model_name is not None:
+            return
+        iv_doc = await self.db.get_latest_index_version(self.tenant_id, self.job_id)
+        if not iv_doc:
+            raise ValueError(f"No embedding index for job {self.job_id}")
+        self._vector_db = iv_doc.get("vector_db", "chroma")
+        self._model_name = iv_doc["model"]
+        self._provider = iv_doc.get("provider", "huggingface")
+        self._configured_dimensions = iv_doc.get("configured_dimensions")
+        self._collection = iv_doc.get("collection", "longparser")
+
+    def _get_relevant_documents(
+        self,
+        query: str,
+        *,
+        run_manager: Optional[CallbackManagerForRetrieverRun] = None,
+    ) -> list[Document]:
+        """Sync retrieval — delegates to existing vector store."""
+        import asyncio
+        return asyncio.get_event_loop().run_until_complete(
+            self._aget_relevant_documents(query, run_manager=run_manager)
+        )
+
+    async def _aget_relevant_documents(
+        self,
+        query: str,
+        *,
+        run_manager: Optional[CallbackManagerForRetrieverRun] = None,
+    ) -> list[Document]:
+        """Async retrieval using existing EmbeddingEngine + vector store."""
+        await self._resolve_index()
+
+        from ..embeddings import EmbeddingEngine
+        from ..vectorstores import get_vector_store
+
+        # Embed query using same model that built the index
+        engine = EmbeddingEngine(
+            provider=self._provider,
+            model_name=self._model_name,
+            dimensions=self._configured_dimensions
+        )
+        query_embedding = engine.embed_query(query)
+
+        # Search vector DB
+        store = get_vector_store(
+            self._vector_db,
+            collection_name=self._collection,
+            index_fingerprint=engine.get_fingerprint(),
+        )
+        filters = {"tenant_id": self.tenant_id, "job_id": self.job_id}
+        results = store.search(query_embedding, top_k=self.top_k, filters=filters)
+
+        # Convert to LangChain Documents
+        documents = []
+        for r in results:
+            meta = r.get("metadata", {})
+            documents.append(Document(
+                page_content=r.get("document", ""),
+                metadata={
+                    "chunk_id": meta.get("chunk_id", r.get("id", "")),
+                    "score": r.get("score", 0),
+                    "chunk_type": meta.get("chunk_type", ""),
+                    "page_numbers": meta.get("page_numbers", []),
+                    "block_ids": meta.get("block_ids", []),
+                },
+            ))
+
+        return documents

longparser/server/chat/schemas.py

@@ -0,0 +1,164 @@
+"""Pydantic models for LongParser Chat API."""
+
+from __future__ import annotations
+
+import os
+import uuid
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+# ---------------------------------------------------------------------------
+# Enums
+# ---------------------------------------------------------------------------
+
+class FactSourceType(str, Enum):
+    """Allowed fact source types."""
+    DOC = "doc"
+    USER = "user"
+    ASSISTANT_INFERENCE = "assistant_inference"  # ephemeral — never persisted
+
+
+# ---------------------------------------------------------------------------
+# Config (read from env with defaults)
+# ---------------------------------------------------------------------------
+
+class ChatConfig(BaseModel):
+    """Chat configuration — all values from env with sensible defaults."""
+
+    llm_provider: str = Field(
+        default_factory=lambda: os.getenv("LONGPARSER_LLM_PROVIDER", "openai")
+    )
+    llm_model: str = Field(
+        default_factory=lambda: os.getenv("LONGPARSER_LLM_MODEL", "gpt-4o")
+    )
+    max_input_tokens: int = Field(
+        default_factory=lambda: int(os.getenv("LONGPARSER_CHAT_MAX_INPUT_TOKENS", "1000"))
+    )
+    max_output_tokens: int = Field(
+        default_factory=lambda: int(os.getenv("LONGPARSER_CHAT_MAX_OUTPUT_TOKENS", "2000"))
+    )
+    max_prompt_tokens: int = Field(
+        default_factory=lambda: int(os.getenv("LONGPARSER_CHAT_MAX_PROMPT_TOKENS", "6000"))
+    )
+    max_top_k: int = Field(
+        default_factory=lambda: int(os.getenv("LONGPARSER_CHAT_MAX_TOP_K", "10"))
+    )
+    rate_limit: int = Field(
+        default_factory=lambda: int(os.getenv("LONGPARSER_CHAT_RATE_LIMIT", "20"))
+    )
+    short_term_turns: int = Field(
+        default_factory=lambda: int(os.getenv("LONGPARSER_CHAT_SHORT_TERM_TURNS", "8"))
+    )
+    summarize_every: int = Field(
+        default_factory=lambda: int(os.getenv("LONGPARSER_CHAT_SUMMARIZE_EVERY", "10"))
+    )
+    extract_facts_every: int = Field(
+        default_factory=lambda: int(os.getenv("LONGPARSER_CHAT_EXTRACT_FACTS_EVERY", "20"))
+    )
+    max_facts: int = Field(
+        default_factory=lambda: int(os.getenv("LONGPARSER_CHAT_MAX_FACTS", "20"))
+    )
+    llm_timeout: float = Field(
+        default_factory=lambda: float(os.getenv("LONGPARSER_LLM_TIMEOUT", "30"))
+    )
+    llm_max_retries: int = Field(
+        default_factory=lambda: int(os.getenv("LONGPARSER_LLM_MAX_RETRIES", "3"))
+    )
+    ttl_days: int = Field(
+        default_factory=lambda: int(os.getenv("LONGPARSER_CHAT_TTL_DAYS", "30"))
+    )
+
+
+# ---------------------------------------------------------------------------
+# Request / Response Models
+# ---------------------------------------------------------------------------
+
+class CreateSessionRequest(BaseModel):
+    """POST /chat/sessions — create a chat session."""
+    job_id: str
+
+
+class ChatRequest(BaseModel):
+    """POST /chat — ask a question."""
+    session_id: str
+    job_id: str
+    question: str
+    llm_provider: Optional[str] = None   # override env default
+    llm_model: Optional[str] = None      # override env default
+    top_k: int = 5
+    idempotency_key: Optional[str] = None
+    require_approval: bool = False       # opt-in HITL review
+
+
+class HITLResumeRequest(BaseModel):
+    """POST /chat/resume — resume a paused HITL chat."""
+    session_id: str
+    thread_id: str                        # LangGraph thread ID
+    action: str                           # "approve" | "edit" | "reject"
+    edited_answer: Optional[str] = None   # only for action="edit"
+
+
+class SourceRef(BaseModel):
+    """A reference to a retrieved chunk used as evidence."""
+    chunk_id: str
+    score: float
+    text: str = ""
+    page_numbers: list[int] = Field(default_factory=list)
+
+
+class ChatResponse(BaseModel):
+    """Response body for POST /chat."""
+    session_id: str
+    turn_id: str
+    answer: str
+    sources: list[SourceRef] = Field(default_factory=list)
+    status: str = "complete"              # "complete" | "pending_review"
+    thread_id: Optional[str] = None       # set when status="pending_review"
+
+
+class LLMAnswer(BaseModel):
+    """Structured LLM output — enforced via with_structured_output."""
+    answer: str
+    cited_chunk_ids: list[str] = Field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# Turn & Fact Models (stored in MongoDB)
+# ---------------------------------------------------------------------------
+
+class Turn(BaseModel):
+    """A single Q&A turn in a chat session."""
+    turn_id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    question: str
+    answer: str
+    sources: list[SourceRef] = Field(default_factory=list)
+    archived: bool = False
+    idempotency_key: Optional[str] = None
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+class Fact(BaseModel):
+    """A long-term fact extracted from conversation."""
+    type: str  # entities_from_doc | user_preferences | decisions
+    source: FactSourceType
+    fact: str
+    supporting_chunk_ids: list[str] = Field(default_factory=list)
+    confidence: float = 0.0
+    created_at: datetime = Field(default_factory=lambda: datetime.now(timezone.utc))
+
+
+class SessionInfo(BaseModel):
+    """Response for GET /chat/sessions/{id}."""
+    session_id: str
+    tenant_id: str
+    job_id: str
+    turn_count: int = 0
+    rolling_summary: str = ""
+    long_term_facts: list[Fact] = Field(default_factory=list)
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+    deleted_at: Optional[datetime] = None