compair-core 0.3.13__tar.gz → 0.3.15__tar.gz

{compair_core-0.3.13 → compair_core-0.3.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compair-core
-Version: 0.3.13
+Version: 0.3.15
 Summary: Open-source foundation of the Compair collaboration platform.
 Author: RocketResearch, Inc.
 License: MIT
@@ -92,6 +92,10 @@ Key environment variables for the core edition:
 - `COMPAIR_REQUIRE_AUTHENTICATION` (`true`) – set to `false` to run the API in single-user mode without login or account management. When disabled, Compair auto-provisions a local user, group, and long-lived session token so you can upload documents immediately.
 - `COMPAIR_SINGLE_USER_USERNAME` / `COMPAIR_SINGLE_USER_NAME` – override the email-style username and display name that are used for the auto-provisioned local user in single-user mode.
 - `COMPAIR_INCLUDE_LEGACY_ROUTES` (`false`) – opt-in to the full legacy API surface (used by the hosted product) when running the core edition. Leave unset to expose only the streamlined single-user endpoints in Swagger.
+- `COMPAIR_EMBEDDING_DIM` – force the embedding vector size stored in the database (defaults to 384 for core, 1536 for cloud). Keep this in sync with whichever embedding model you configure.
+- `COMPAIR_VECTOR_BACKEND` (`auto`) – set to `pgvector` when running against PostgreSQL with the pgvector extension, or `json` to store embeddings as JSON (the default for SQLite deployments).
+- `COMPAIR_GENERATION_PROVIDER` (`local`) – choose how feedback is produced. Options: `local` (call the bundled FastAPI service), `openai` (use ChatGPT-compatible APIs with an API key), or `fallback` (skip generation and surface similar references only).
+- `COMPAIR_OPENAI_API_KEY` / `COMPAIR_OPENAI_MODEL` – when using the OpenAI provider, supply your API key and optional model name (defaults to `gpt-4o-mini`). The fallback kicks in automatically if the key or SDK is unavailable.
 
 See `compair_core/server/settings.py` for the full settings surface.
 

{compair_core-0.3.13 → compair_core-0.3.15}/README.md

@@ -57,6 +57,10 @@ Key environment variables for the core edition:
 - `COMPAIR_REQUIRE_AUTHENTICATION` (`true`) – set to `false` to run the API in single-user mode without login or account management. When disabled, Compair auto-provisions a local user, group, and long-lived session token so you can upload documents immediately.
 - `COMPAIR_SINGLE_USER_USERNAME` / `COMPAIR_SINGLE_USER_NAME` – override the email-style username and display name that are used for the auto-provisioned local user in single-user mode.
 - `COMPAIR_INCLUDE_LEGACY_ROUTES` (`false`) – opt-in to the full legacy API surface (used by the hosted product) when running the core edition. Leave unset to expose only the streamlined single-user endpoints in Swagger.
+- `COMPAIR_EMBEDDING_DIM` – force the embedding vector size stored in the database (defaults to 384 for core, 1536 for cloud). Keep this in sync with whichever embedding model you configure.
+- `COMPAIR_VECTOR_BACKEND` (`auto`) – set to `pgvector` when running against PostgreSQL with the pgvector extension, or `json` to store embeddings as JSON (the default for SQLite deployments).
+- `COMPAIR_GENERATION_PROVIDER` (`local`) – choose how feedback is produced. Options: `local` (call the bundled FastAPI service), `openai` (use ChatGPT-compatible APIs with an API key), or `fallback` (skip generation and surface similar references only).
+- `COMPAIR_OPENAI_API_KEY` / `COMPAIR_OPENAI_MODEL` – when using the OpenAI provider, supply your API key and optional model name (defaults to `gpt-4o-mini`). The fallback kicks in automatically if the key or SDK is unavailable.
 
 See `compair_core/server/settings.py` for the full settings surface.
 

{compair_core-0.3.13 → compair_core-0.3.15}/compair_core/compair/embeddings.py

@@ -23,7 +23,17 @@ class Embedder:
 
         if self._cloud_impl is None:
             self.model = os.getenv("COMPAIR_LOCAL_EMBED_MODEL", "hash-embedding")
-            self.dimension = int(os.getenv("COMPAIR_LOCAL_EMBED_DIM", "384"))
+            default_dim = 1536 if self.edition == "cloud" else 384
+            dim_env = (
+                os.getenv("COMPAIR_EMBEDDING_DIM")
+                or os.getenv("COMPAIR_EMBEDDING_DIMENSION")
+                or os.getenv("COMPAIR_LOCAL_EMBED_DIM")
+                or str(default_dim)
+            )
+            try:
+                self.dimension = int(dim_env)
+            except ValueError:  # pragma: no cover - invalid configuration
+                self.dimension = default_dim
             base_url = os.getenv("COMPAIR_LOCAL_MODEL_URL", "http://local-model:9000")
             route = os.getenv("COMPAIR_LOCAL_EMBED_ROUTE", "/embed")
             self.endpoint = f"{base_url.rstrip('/')}{route}"

compair_core-0.3.15/compair_core/compair/feedback.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+import os
+from typing import Any, Iterable, List
+
+import requests
+
+from .logger import log_event
+from .models import Document, User
+
+try:
+    import openai  # type: ignore
+except ImportError:  # pragma: no cover - optional dependency
+    openai = None  # type: ignore
+
+try:
+    from compair_cloud.feedback import Reviewer as CloudReviewer  # type: ignore
+    from compair_cloud.feedback import get_feedback as cloud_get_feedback  # type: ignore
+except (ImportError, ModuleNotFoundError):
+    CloudReviewer = None  # type: ignore
+    cloud_get_feedback = None  # type: ignore
+
+
+class Reviewer:
+    """Edition-aware wrapper that selects a feedback provider based on configuration."""
+
+    def __init__(self) -> None:
+        self.edition = os.getenv("COMPAIR_EDITION", "core").lower()
+        self.provider = os.getenv("COMPAIR_GENERATION_PROVIDER", "local").lower()
+        self.length_map = {
+            "Brief": "1–2 short sentences",
+            "Detailed": "A couple short paragraphs",
+            "Verbose": "As thorough as reasonably possible without repeating information",
+        }
+
+        self._cloud_impl = None
+        self._openai_client = None
+        self.openai_model = os.getenv("COMPAIR_OPENAI_MODEL", "gpt-4o-mini")
+
+        if self.edition == "cloud" and CloudReviewer is not None:
+            self._cloud_impl = CloudReviewer()
+            self.provider = "cloud"
+        else:
+            if self.provider == "openai":
+                api_key = os.getenv("COMPAIR_OPENAI_API_KEY")
+                if api_key and openai is not None:
+                    # Support both legacy (ChatCompletion) and new SDKs
+                    if hasattr(openai, "api_key"):
+                        openai.api_key = api_key  # type: ignore[assignment]
+                    if hasattr(openai, "OpenAI"):
+                        try:  # pragma: no cover - optional runtime dependency
+                            self._openai_client = openai.OpenAI(api_key=api_key)  # type: ignore[attr-defined]
+                        except Exception:  # pragma: no cover - if instantiation fails
+                            self._openai_client = None
+                if self._openai_client is None and not hasattr(openai, "ChatCompletion"):
+                    log_event("openai_feedback_unavailable", reason="openai_library_missing")
+                    self.provider = "fallback"
+            if self.provider == "local":
+                self.model = os.getenv("COMPAIR_LOCAL_GENERATION_MODEL", "local-feedback")
+                base_url = os.getenv("COMPAIR_LOCAL_MODEL_URL", "http://local-model:9000")
+                route = os.getenv("COMPAIR_LOCAL_GENERATION_ROUTE", "/generate")
+                self.endpoint = f"{base_url.rstrip('/')}{route}"
+            else:
+                self.model = "external"
+                self.endpoint = None
+
+    @property
+    def is_cloud(self) -> bool:
+        return self._cloud_impl is not None
+
+
+def _reference_snippets(references: Iterable[Any], limit: int = 3) -> List[str]:
+    snippets: List[str] = []
+    for ref in references:
+        snippet = getattr(ref, "content", "") or ""
+        snippet = snippet.replace("\n", " ").strip()
+        if snippet:
+            snippets.append(snippet[:200])
+        if len(snippets) == limit:
+            break
+    return snippets
+
+
+def _fallback_feedback(text: str, references: list[Any]) -> str:
+    snippets = _reference_snippets(references)
+    if not snippets:
+        return "NONE"
+    joined = "; ".join(snippets)
+    return f"Consider aligning with these reference passages: {joined}"
+
+
+def _openai_feedback(
+    reviewer: Reviewer,
+    doc: Document,
+    text: str,
+    references: list[Any],
+    user: User,
+) -> str | None:
+    if openai is None:
+        return None
+    instruction = reviewer.length_map.get(user.preferred_feedback_length, "1–2 short sentences")
+    ref_text = "\n\n".join(_reference_snippets(references, limit=3))
+    messages = [
+        {
+            "role": "system",
+            "content": (
+                "You are Compair, an assistant that delivers concise, actionable feedback on a user's document. "
+                "Focus on clarity, cohesion, and usefulness."
+            ),
+        },
+        {
+            "role": "user",
+            "content": (
+                f"Document:\n{text}\n\nHelpful reference excerpts:\n{ref_text or 'None provided'}\n\n"
+                f"Respond with {instruction} that highlights the most valuable revision to make next."
+            ),
+        },
+    ]
+
+    try:
+        if reviewer._openai_client is not None and hasattr(reviewer._openai_client, "responses"):
+            response = reviewer._openai_client.responses.create(  # type: ignore[union-attr]
+                model=reviewer.openai_model,
+                input=messages,
+                max_output_tokens=256,
+            )
+            content = getattr(response, "output_text", None)
+            if not content and hasattr(response, "outputs"):
+                # Legacy compatibility: join content parts
+                parts = []
+                for item in getattr(response, "outputs", []):
+                    parts.extend(getattr(item, "content", []))
+                content = " ".join(getattr(part, "text", "") for part in parts)
+        elif hasattr(openai, "ChatCompletion"):
+            chat_response = openai.ChatCompletion.create(  # type: ignore[attr-defined]
+                model=reviewer.openai_model,
+                messages=messages,
+                temperature=0.3,
+                max_tokens=256,
+            )
+            content = (
+                chat_response["choices"][0]["message"]["content"].strip()  # type: ignore[index, assignment]
+            )
+        else:
+            content = None
+    except Exception as exc:  # pragma: no cover - network/API failure
+        log_event("openai_feedback_failed", error=str(exc))
+        content = None
+    if content:
+        content = content.strip()
+        if content:
+            return content
+    return None
+
+
+def _local_feedback(
+    reviewer: Reviewer,
+    text: str,
+    references: list[Any],
+    user: User,
+) -> str | None:
+    payload = {
+        "document": text,
+        "references": [getattr(ref, "content", "") for ref in references],
+        "length_instruction": reviewer.length_map.get(
+            user.preferred_feedback_length,
+            "1–2 short sentences",
+        ),
+    }
+
+    try:
+        response = requests.post(reviewer.endpoint, json=payload, timeout=30)
+        response.raise_for_status()
+        data = response.json()
+        feedback = data.get("feedback") or data.get("text")
+        if feedback:
+            return str(feedback).strip()
+    except Exception as exc:  # pragma: no cover - network failures stay graceful
+        log_event("local_feedback_failed", error=str(exc))
+
+    return None
+
+
+def get_feedback(
+    reviewer: Reviewer,
+    doc: Document,
+    text: str,
+    references: list[Any],
+    user: User,
+) -> str:
+    if reviewer.is_cloud and cloud_get_feedback is not None:
+        return cloud_get_feedback(reviewer._cloud_impl, doc, text, references, user)  # type: ignore[arg-type]
+
+    if reviewer.provider == "openai":
+        feedback = _openai_feedback(reviewer, doc, text, references, user)
+        if feedback:
+            return feedback
+
+    if reviewer.provider == "local" and getattr(reviewer, "endpoint", None):
+        feedback = _local_feedback(reviewer, text, references, user)
+        if feedback:
+            return feedback
+
+    return _fallback_feedback(text, references)

{compair_core-0.3.13 → compair_core-0.3.15}/compair_core/compair/main.py

@@ -12,7 +12,17 @@ from sqlalchemy.orm import Session as SASession
 
 from .embeddings import create_embedding, Embedder
 from .feedback import get_feedback, Reviewer
-from .models import Chunk, Document, Feedback, Group, Note, Reference, User
+from .models import (
+    Chunk,
+    Document,
+    Feedback,
+    Group,
+    Note,
+    Reference,
+    User,
+    VECTOR_BACKEND,
+    cosine_similarity,
+)
 from .utils import chunk_text, log_activity
 
 
@@ -159,22 +169,41 @@ def process_text(
         Chunk.note_id == note_id,
     ).first()
 
+    references: list[Chunk] = []
     if generate_feedback and existing_chunk:
         doc_group_ids = [g.group_id for g in doc.groups]
-        references = (
-            session.query(Chunk)
-            .join(Chunk.document)
-            .join(Document.groups)
-            .filter(
-                Document.is_published.is_(True),
-                Document.document_id != doc.document_id,
-                Chunk.chunk_type == "document",
-                Group.group_id.in_(doc_group_ids),
+        target_embedding = existing_chunk.embedding
+
+        if target_embedding is not None:
+            base_query = (
+                session.query(Chunk)
+                .join(Chunk.document)
+                .join(Document.groups)
+                .filter(
+                    Document.is_published.is_(True),
+                    Document.document_id != doc.document_id,
+                    Chunk.chunk_type == "document",
+                    Group.group_id.in_(doc_group_ids),
+                )
             )
-            .order_by(Chunk.embedding.cosine_distance(existing_chunk.embedding))
-            .limit(3)
-            .all()
-        )
+
+            if VECTOR_BACKEND == "pgvector":
+                references = (
+                    base_query.order_by(
+                        Chunk.embedding.cosine_distance(existing_chunk.embedding)
+                    )
+                    .limit(3)
+                    .all()
+                )
+            else:
+                candidates = base_query.all()
+                scored: list[tuple[float, Chunk]] = []
+                for candidate in candidates:
+                    score = cosine_similarity(candidate.embedding, target_embedding)
+                    if score is not None:
+                        scored.append((score, candidate))
+                scored.sort(key=lambda item: item[0], reverse=True)
+                references = [chunk for _, chunk in scored[:3]]
 
         sql_references: list[Reference] = []
         for ref_chunk in references:

{compair_core-0.3.13 → compair_core-0.3.15}/compair_core/compair/models.py

@@ -5,9 +5,15 @@ import hashlib
 import os
 import secrets
 from datetime import datetime, timezone
+from math import sqrt
+from typing import Sequence
 from uuid import uuid4
 
-from pgvector.sqlalchemy import Vector
+try:  # Optional: only required when using pgvector backend
+    from pgvector.sqlalchemy import Vector
+except ImportError:  # pragma: no cover - optional dependency in core
+    Vector = None  # type: ignore[assignment]
+
 from sqlalchemy import (
     Boolean,
     Column,
@@ -15,6 +21,7 @@ from sqlalchemy import (
     ForeignKey,
     Identity,
     Integer,
+    JSON,
     String,
     Table,
     Text,
@@ -27,6 +34,69 @@ from sqlalchemy.orm import (
     relationship,
 )
 
+_EDITION = os.getenv("COMPAIR_EDITION", "core").lower()
+_DEFAULT_DIM = 1536 if _EDITION == "cloud" else 384
+_DIM_ENV = (
+    os.getenv("COMPAIR_EMBEDDING_DIM")
+    or os.getenv("COMPAIR_EMBEDDING_DIMENSION")
+    or os.getenv("COMPAIR_LOCAL_EMBED_DIM")
+    or str(_DEFAULT_DIM)
+)
+
+try:
+    EMBEDDING_DIMENSION = int(_DIM_ENV)
+except ValueError:  # pragma: no cover - invalid configuration
+    EMBEDDING_DIMENSION = _DEFAULT_DIM
+
+
+def _detect_vector_backend() -> str:
+    explicit = os.getenv("COMPAIR_VECTOR_BACKEND")
+    if explicit:
+        return explicit.lower()
+
+    db = os.getenv("DB")
+    db_user = os.getenv("DB_USER")
+    db_passw = os.getenv("DB_PASSW")
+    db_url = os.getenv("DB_URL")
+    database_url = os.getenv("DATABASE_URL", "")
+
+    if all([db, db_user, db_passw, db_url]):
+        return "pgvector"
+    if database_url.lower().startswith(("postgres://", "postgresql://")):
+        return "pgvector"
+    return "json"
+
+
+VECTOR_BACKEND = _detect_vector_backend()
+
+
+def _embedding_column():
+    if VECTOR_BACKEND == "pgvector":
+        if Vector is None:
+            raise RuntimeError(
+                "pgvector is required when COMPAIR_VECTOR_BACKEND is set to 'pgvector'."
+            )
+        return mapped_column(
+            Vector(EMBEDDING_DIMENSION),
+            nullable=True,
+            default=None,
+        )
+    # Store embeddings as JSON arrays (works across SQLite/Postgres without pgvector)
+    return mapped_column(JSON, nullable=True, default=None)
+
+
+def cosine_similarity(vec1: Sequence[float] | None, vec2: Sequence[float] | None) -> float | None:
+    if not vec1 or not vec2:
+        return None
+    if len(vec1) != len(vec2):
+        return None
+    dot = sum(a * b for a, b in zip(vec1, vec2))
+    norm1 = sqrt(sum(a * a for a in vec1))
+    norm2 = sqrt(sum(b * b for b in vec2))
+    if norm1 == 0 or norm2 == 0:
+        return None
+    return dot / (norm1 * norm2)
+
 
 class Base(DeclarativeBase, MappedAsDataclass):
     pass
@@ -213,10 +283,10 @@ class Document(BaseObject):
     doc_type: Mapped[str]
     datetime_created: Mapped[datetime]
     datetime_modified: Mapped[datetime]
+    embedding: Mapped[list[float] | None] = _embedding_column()
     file_key: Mapped[str | None] = mapped_column(String, nullable=True, default=None)
     image_key: Mapped[str | None] = mapped_column(String, nullable=True, default=None)
     is_published: Mapped[bool] = mapped_column(Boolean, default=False)
-    embedding = mapped_column(Vector(1536))
 
     user = relationship("User", back_populates="documents")
     groups = relationship("Group", secondary="document_to_group", back_populates="documents")
@@ -249,8 +319,8 @@ class Note(Base):
     author_id: Mapped[str] = mapped_column(ForeignKey("user.user_id", ondelete="CASCADE"), index=True)
     group_id: Mapped[str | None] = mapped_column(ForeignKey("group.group_id", ondelete="CASCADE"), index=True, nullable=True)
     content: Mapped[str] = mapped_column(Text)
+    embedding: Mapped[list[float] | None] = _embedding_column()
     datetime_created: Mapped[datetime] = mapped_column(default=datetime.now(timezone.utc))
-    embedding = mapped_column(Vector(1536))
 
     document = relationship("Document", back_populates="notes")
     author = relationship("User", back_populates="notes")
@@ -279,7 +349,7 @@ class Chunk(Base):
     document_id: Mapped[str | None] = mapped_column(ForeignKey("document.document_id", ondelete="CASCADE"), index=True, nullable=True)
     note_id: Mapped[str | None] = mapped_column(ForeignKey("note.note_id", ondelete="CASCADE"), index=True, nullable=True)
     chunk_type: Mapped[str] = mapped_column(String(16), default="document")
-    embedding = mapped_column(Vector(1536))
+    embedding: Mapped[list[float] | None] = _embedding_column()
 
     document = relationship("Document", back_populates="chunks")
     note = relationship("Note", back_populates="chunks")

compair_core-0.3.15/compair_core/server/local_model/app.py

@@ -0,0 +1,87 @@
+"""Minimal FastAPI application serving local embedding and generation endpoints."""
+from __future__ import annotations
+
+import hashlib
+import os
+from typing import List
+
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+app = FastAPI(title="Compair Local Model", version="0.1.0")
+
+_DEFAULT_DIM = 384
+_DIM_ENV = (
+    os.getenv("COMPAIR_EMBEDDING_DIM")
+    or os.getenv("COMPAIR_EMBEDDING_DIMENSION")
+    or os.getenv("COMPAIR_LOCAL_EMBED_DIM")
+    or str(_DEFAULT_DIM)
+)
+try:
+    EMBED_DIMENSION = int(_DIM_ENV)
+except ValueError:  # pragma: no cover - invalid configuration
+    EMBED_DIMENSION = _DEFAULT_DIM
+
+
+def _hash_embedding(text: str, dimension: int = EMBED_DIMENSION) -> List[float]:
+    if not text:
+        text = " "
+    digest = hashlib.sha256(text.encode("utf-8", "ignore")).digest()
+    vector: List[float] = []
+    while len(vector) < dimension:
+        for byte in digest:
+            vector.append((byte / 255.0) * 2 - 1)
+            if len(vector) == dimension:
+                break
+        digest = hashlib.sha256(digest).digest()
+    return vector
+
+
+class EmbedRequest(BaseModel):
+    text: str
+
+
+class EmbedResponse(BaseModel):
+    embedding: List[float]
+
+
+class GenerateRequest(BaseModel):
+    # Legacy format used by the CLI shim
+    system: str | None = None
+    prompt: str | None = None
+    verbosity: str | None = None
+
+    # Core API payload (document + references)
+    document: str | None = None
+    references: List[str] | None = None
+    length_instruction: str | None = None
+
+
+class GenerateResponse(BaseModel):
+    feedback: str
+
+
+@app.post("/embed", response_model=EmbedResponse)
+def embed(request: EmbedRequest) -> EmbedResponse:
+    return EmbedResponse(embedding=_hash_embedding(request.text))
+
+
+@app.post("/generate", response_model=GenerateResponse)
+def generate(request: GenerateRequest) -> GenerateResponse:
+    # Determine the main text input (document or prompt)
+    text_input = request.document or request.prompt or ""
+    text_input = text_input.strip()
+
+    if not text_input:
+        return GenerateResponse(feedback="NONE")
+
+    first_sentence = text_input.split("\n", 1)[0][:200]
+    verbosity = request.length_instruction or request.verbosity or "brief response"
+    ref_snippet = ""
+    if request.references:
+        top_ref = (request.references[0] or "").strip()
+        if top_ref:
+            ref_snippet = f" Reference: {top_ref[:160]}"
+
+    feedback = f"[local-feedback] {verbosity}: {first_sentence}{ref_snippet}".strip()
+    return GenerateResponse(feedback=feedback or "NONE")

{compair_core-0.3.13 → compair_core-0.3.15}/compair_core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compair-core
-Version: 0.3.13
+Version: 0.3.15
 Summary: Open-source foundation of the Compair collaboration platform.
 Author: RocketResearch, Inc.
 License: MIT
@@ -92,6 +92,10 @@ Key environment variables for the core edition:
 - `COMPAIR_REQUIRE_AUTHENTICATION` (`true`) – set to `false` to run the API in single-user mode without login or account management. When disabled, Compair auto-provisions a local user, group, and long-lived session token so you can upload documents immediately.
 - `COMPAIR_SINGLE_USER_USERNAME` / `COMPAIR_SINGLE_USER_NAME` – override the email-style username and display name that are used for the auto-provisioned local user in single-user mode.
 - `COMPAIR_INCLUDE_LEGACY_ROUTES` (`false`) – opt-in to the full legacy API surface (used by the hosted product) when running the core edition. Leave unset to expose only the streamlined single-user endpoints in Swagger.
+- `COMPAIR_EMBEDDING_DIM` – force the embedding vector size stored in the database (defaults to 384 for core, 1536 for cloud). Keep this in sync with whichever embedding model you configure.
+- `COMPAIR_VECTOR_BACKEND` (`auto`) – set to `pgvector` when running against PostgreSQL with the pgvector extension, or `json` to store embeddings as JSON (the default for SQLite deployments).
+- `COMPAIR_GENERATION_PROVIDER` (`local`) – choose how feedback is produced. Options: `local` (call the bundled FastAPI service), `openai` (use ChatGPT-compatible APIs with an API key), or `fallback` (skip generation and surface similar references only).
+- `COMPAIR_OPENAI_API_KEY` / `COMPAIR_OPENAI_MODEL` – when using the OpenAI provider, supply your API key and optional model name (defaults to `gpt-4o-mini`). The fallback kicks in automatically if the key or SDK is unavailable.
 
 See `compair_core/server/settings.py` for the full settings surface.
 

{compair_core-0.3.13 → compair_core-0.3.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "compair-core"
-version = "0.3.13"
+version = "0.3.15"
 description = "Open-source foundation of the Compair collaboration platform."
 readme = "README.md"
 license = { text = "MIT" }

compair_core-0.3.13/compair_core/compair/feedback.py

@@ -1,79 +0,0 @@
-from __future__ import annotations
-
-import os
-import requests
-from typing import Any
-
-from .logger import log_event
-from .models import Document, User
-
-try:
-    from compair_cloud.feedback import Reviewer as CloudReviewer  # type: ignore
-    from compair_cloud.feedback import get_feedback as cloud_get_feedback  # type: ignore
-except (ImportError, ModuleNotFoundError):
-    CloudReviewer = None  # type: ignore
-    cloud_get_feedback = None  # type: ignore
-
-
-class Reviewer:
-    """Edition-aware wrapper that falls back to the local feedback endpoint."""
-
-    def __init__(self) -> None:
-        self.edition = os.getenv("COMPAIR_EDITION", "core").lower()
-        self._cloud_impl = None
-        if self.edition == "cloud" and CloudReviewer is not None:
-            self._cloud_impl = CloudReviewer()
-        else:
-            self.client = None
-            self.model = os.getenv("COMPAIR_LOCAL_GENERATION_MODEL", "local-feedback")
-            base_url = os.getenv("COMPAIR_LOCAL_MODEL_URL", "http://local-model:9000")
-            route = os.getenv("COMPAIR_LOCAL_GENERATION_ROUTE", "/generate")
-            self.endpoint = f"{base_url.rstrip('/')}{route}"
-
-    @property
-    def is_cloud(self) -> bool:
-        return self._cloud_impl is not None
-
-
-def _fallback_feedback(text: str, references: list[Any]) -> str:
-    if not references:
-        return "NONE"
-    top_ref = references[0]
-    snippet = getattr(top_ref, "content", "") or ""
-    snippet = snippet.replace("\n", " ").strip()[:200]
-    if not snippet:
-        return "NONE"
-    return f"Check alignment with this reference: {snippet}"
-
-
-def get_feedback(
-    reviewer: Reviewer,
-    doc: Document,
-    text: str,
-    references: list[Any],
-    user: User,
-) -> str:
-    if reviewer.is_cloud and cloud_get_feedback is not None:
-        return cloud_get_feedback(reviewer._cloud_impl, doc, text, references, user)  # type: ignore[arg-type]
-
-    payload = {
-        "document": text,
-        "references": [getattr(ref, "content", "") for ref in references],
-        "length_instruction": {
-            "Brief": "1–2 short sentences",
-            "Detailed": "A couple short paragraphs",
-            "Verbose": "As thorough as reasonably possible without repeating information",
-        }.get(user.preferred_feedback_length, "1–2 short sentences"),
-    }
-
-    try:
-        response = requests.post(reviewer.endpoint, json=payload, timeout=30)
-        response.raise_for_status()
-        data = response.json()
-        feedback = data.get("feedback")
-        if feedback:
-            return feedback
-    except Exception as exc:  # pragma: no cover - network failures stay graceful
-        log_event("local_feedback_failed", error=str(exc))
-
-    return _fallback_feedback(text, references)

compair_core-0.3.13/compair_core/server/local_model/app.py

@@ -1,62 +0,0 @@
-"""Minimal FastAPI application serving local embedding and generation endpoints."""
-from __future__ import annotations
-
-import hashlib
-from typing import List
-
-from fastapi import FastAPI
-from pydantic import BaseModel
-
-app = FastAPI(title="Compair Local Model", version="0.1.0")
-
-EMBED_DIMENSION = 384
-
-
-def _hash_embedding(text: str, dimension: int = EMBED_DIMENSION) -> List[float]:
-    if not text:
-        text = " "
-    digest = hashlib.sha256(text.encode("utf-8", "ignore")).digest()
-    vector: List[float] = []
-    while len(vector) < dimension:
-        for byte in digest:
-            vector.append((byte / 255.0) * 2 - 1)
-            if len(vector) == dimension:
-                break
-        digest = hashlib.sha256(digest).digest()
-    return vector
-
-
-class EmbedRequest(BaseModel):
-    text: str
-
-
-class EmbedResponse(BaseModel):
-    embedding: List[float]
-
-
-class GenerateRequest(BaseModel):
-    system: str | None = None
-    prompt: str
-    verbosity: str | None = None
-
-
-class GenerateResponse(BaseModel):
-    text: str
-
-
-@app.post("/embed", response_model=EmbedResponse)
-def embed(request: EmbedRequest) -> EmbedResponse:
-    return EmbedResponse(embedding=_hash_embedding(request.text))
-
-
-@app.post("/generate", response_model=GenerateResponse)
-def generate(request: GenerateRequest) -> GenerateResponse:
-    prompt = request.prompt.strip()
-    if not prompt:
-        return GenerateResponse(text="NONE")
-
-    first_sentence = prompt.split("\n", 1)[0][:200]
-    verbosity = request.verbosity or "default"
-    return GenerateResponse(
-        text=f"[local-{verbosity}] Key takeaway: {first_sentence}"
-    )