remdb 0.2.6__py3-none-any.whl → 0.3.103__py3-none-any.whl

rem/cli/commands/scaffold.py

@@ -0,0 +1,47 @@
+"""
+Scaffold command - generate project structure for REM-based applications.
+
+TODO: Implement this command to generate:
+- my_app/main.py (entry point with create_app)
+- my_app/models.py (example CoreModel subclass)
+- my_app/routers/ (example FastAPI router)
+- schemas/agents/ (example agent schema)
+- schemas/evaluators/ (example evaluator)
+- sql/migrations/ (empty migrations directory)
+- pyproject.toml (with remdb dependency)
+- README.md (basic usage instructions)
+
+Usage:
+    rem scaffold my-app
+    rem scaffold my-app --with-examples  # Include example models/routers/tools
+"""
+
+import click
+
+
+@click.command()
+@click.argument("name")
+@click.option("--with-examples", is_flag=True, help="Include example code")
+def scaffold(name: str, with_examples: bool) -> None:
+    """
+    Generate a new REM-based project structure.
+
+    NAME is the project directory name to create.
+    """
+    click.echo(f"TODO: Scaffold command not yet implemented")
+    click.echo(f"Would create project: {name}")
+    click.echo(f"With examples: {with_examples}")
+    click.echo()
+    click.echo("For now, manually create this structure:")
+    click.echo(f"""
+{name}/
+├── {name.replace('-', '_')}/
+│   ├── main.py           # Entry point (create_app + extensions)
+│   ├── models.py         # Custom models (inherit CoreModel)
+│   └── routers/          # Custom FastAPI routers
+├── schemas/
+│   ├── agents/           # Custom agent YAML schemas
+│   └── evaluators/       # Custom evaluator schemas
+├── sql/migrations/       # Custom SQL migrations
+└── pyproject.toml
+""")

rem/cli/commands/schema.py

@@ -29,14 +29,14 @@ from ...services.postgres.schema_generator import SchemaGenerator
     "--output",
     "-o",
     type=click.Path(path_type=Path),
-    default="install_models.sql",
-    help="Output SQL file (default: install_models.sql)",
+    default="002_install_models.sql",
+    help="Output SQL file (default: 002_install_models.sql)",
 )
 @click.option(
     "--output-dir",
     type=click.Path(path_type=Path),
     default=None,
-    help=f"Base output directory (default: {settings.sql_dir})",
+    help=f"Base output directory (default: {settings.sql_dir}/migrations)",
 )
 def generate(models: Path, output: Path, output_dir: Path | None):
     """
@@ -48,13 +48,13 @@ def generate(models: Path, output: Path, output_dir: Path | None):
     - KV_STORE triggers for cache maintenance
     - Indexes (foreground only)
 
-    Output is written to src/rem/sql/install_models.sql by default.
+    Output is written to src/rem/sql/migrations/002_install_models.sql by default.
 
     Example:
         rem db schema generate --models src/rem/models/entities
 
     This creates:
-    - src/rem/sql/install_models.sql - Entity tables and triggers
+    - src/rem/sql/migrations/002_install_models.sql - Entity tables and triggers
     - src/rem/sql/background_indexes.sql - HNSW indexes (apply after data load)
 
     After generation, apply with:
@@ -62,8 +62,8 @@ def generate(models: Path, output: Path, output_dir: Path | None):
     """
     click.echo(f"Discovering models in {models}")
 
-    # Use settings.sql_dir if not provided
-    actual_output_dir = output_dir or Path(settings.sql_dir)
+    # Default to migrations directory
+    actual_output_dir = output_dir or Path(settings.sql_dir) / "migrations"
     generator = SchemaGenerator(output_dir=actual_output_dir)
 
     # Generate schema
@@ -73,10 +73,10 @@ def generate(models: Path, output: Path, output_dir: Path | None):
         click.echo(f"✓ Schema generated: {len(generator.schemas)} tables")
         click.echo(f"✓ Written to: {actual_output_dir / output.name}")
 
-        # Generate background indexes
+        # Generate background indexes in parent sql dir
         background_indexes = generator.generate_background_indexes()
         if background_indexes:
-            bg_file = actual_output_dir / "background_indexes.sql"
+            bg_file = Path(settings.sql_dir) / "background_indexes.sql"
             bg_file.write_text(background_indexes)
             click.echo(f"✓ Background indexes: {bg_file}")
 

rem/cli/main.py

@@ -14,9 +14,17 @@ from pathlib import Path
 import click
 from loguru import logger
 
+# Import version from package
+try:
+    from importlib.metadata import version
+    __version__ = version("remdb")
+except Exception:
+    __version__ = "unknown"
+
 
 @click.group()
 @click.option("--verbose", "-v", is_flag=True, help="Enable verbose logging")
+@click.version_option(version=__version__, prog_name="rem")
 def cli(verbose: bool):
     """REM - Resources Entities Moments system CLI."""
     if verbose:
@@ -67,6 +75,7 @@ from .commands.experiments import experiments as experiments_group
 from .commands.configure import register_command as register_configure_command
 from .commands.serve import register_command as register_serve_command
 from .commands.mcp import register_command as register_mcp_command
+from .commands.scaffold import scaffold as scaffold_command
 
 register_schema_commands(schema)
 register_db_commands(db)
@@ -77,6 +86,7 @@ register_configure_command(cli)
 register_serve_command(cli)
 register_mcp_command(cli)
 cli.add_command(experiments_group)
+cli.add_command(scaffold_command)
 
 
 def main():

rem/config.py

@@ -15,7 +15,7 @@ File Format (~/.rem/config.yaml):
       pool_max_size: 20
 
     llm:
-      default_model: anthropic:claude-sonnet-4-5-20250929
+      default_model: openai:gpt-4.1
       openai_api_key: sk-...
       anthropic_api_key: sk-ant-...
 
@@ -216,7 +216,7 @@ def get_default_config() -> dict[str, Any]:
             "pool_max_size": 20,
         },
         "llm": {
-            "default_model": "anthropic:claude-sonnet-4-5-20250929",
+            "default_model": "openai:gpt-4.1",
             "default_temperature": 0.5,
             # API keys will be prompted for in wizard
             # "openai_api_key": "",

rem/models/core/core_model.py

@@ -52,7 +52,13 @@ class CoreModel(BaseModel):
         default=None, description="Tenant identifier for multi-tenancy isolation"
     )
     user_id: Optional[str] = Field(
-        default=None, description="Owner user identifier (tenant-scoped)"
+        default=None,
+        description=(
+            "Owner user identifier (tenant-scoped). This is a VARCHAR(256), not a UUID, "
+            "to allow flexibility for external identity providers. Typically generated as "
+            "a hash of the user's email address. In future, other strong unique claims "
+            "(e.g., OAuth sub, verified phone) could also be used for generation."
+        ),
     )
     graph_edges: list[dict] = Field(
         default_factory=list,

rem/models/entities/__init__.py

@@ -5,6 +5,9 @@ Core entity types for the REM system:
 - Resources: Base content units (documents, conversations, artifacts)
 - ImageResources: Image-specific resources with CLIP embeddings
 - Messages: Communication content
+- Sessions: Conversation sessions (normal or evaluation mode)
+- SharedSessions: Session sharing between users for collaboration
+- Feedback: User feedback on messages/sessions with trace integration
 - Users: User entities
 - Files: File metadata and tracking
 - Moments: Temporal narratives (meetings, coding sessions, conversations)
@@ -19,6 +22,8 @@ All entities inherit from CoreModel and support:
 - Natural language labels for conversational queries
 """
 
+from .domain_resource import DomainResource
+from .feedback import Feedback, FeedbackCategory
 from .file import File
 from .image_resource import ImageResource
 from .message import Message
@@ -27,12 +32,28 @@ from .ontology import Ontology
 from .ontology_config import OntologyConfig
 from .resource import Resource
 from .schema import Schema
+from .session import Session, SessionMode
+from .shared_session import (
+    SharedSession,
+    SharedSessionCreate,
+    SharedWithMeResponse,
+    SharedWithMeSummary,
+)
 from .user import User, UserTier
 
 __all__ = [
     "Resource",
+    "DomainResource",
     "ImageResource",
     "Message",
+    "Session",
+    "SessionMode",
+    "SharedSession",
+    "SharedSessionCreate",
+    "SharedWithMeResponse",
+    "SharedWithMeSummary",
+    "Feedback",
+    "FeedbackCategory",
     "User",
     "UserTier",
     "File",

rem/models/entities/domain_resource.py

@@ -0,0 +1,38 @@
+"""
+DomainResource - Curated internal knowledge in REM.
+
+DomainResources are a specialized subclass of Resource for storing curated,
+domain-specific internal knowledge that is not part of general knowledge.
+This includes proprietary information, internal documentation, institutional
+knowledge, and other content that requires more careful curation.
+
+Key Differences from Resource:
+- Intended for curated, internal knowledge (not raw ingested content)
+- Higher quality bar - content is reviewed/vetted before ingestion
+- May contain proprietary or sensitive information
+- Subject to different retention/governance policies
+
+Use Cases:
+- Internal documentation and procedures
+- Proprietary research and analysis
+- Institutional knowledge bases
+- Domain-specific ontologies and taxonomies
+- Curated best practices and guidelines
+"""
+
+from .resource import Resource
+
+
+class DomainResource(Resource):
+    """
+    Curated domain-specific knowledge resource.
+
+    Inherits all fields from Resource but stored in a separate table
+    (domain_resources) to distinguish curated internal knowledge from
+    general ingested content.
+
+    The schema is identical to Resource, allowing seamless migration
+    of content between tables as curation status changes.
+    """
+
+    pass

rem/models/entities/feedback.py

@@ -0,0 +1,123 @@
+"""
+Feedback - User feedback on chat messages and sessions.
+
+Feedback allows users to rate and categorize responses, providing
+data for evaluation and model improvement. Feedback can be attached
+to specific messages or entire sessions.
+
+Trace Integration:
+- Feedback references trace_id/span_id for OTEL/Phoenix integration
+- Can attach annotations to Phoenix spans for unified observability
+
+Predefined Categories (system-defined, extensible):
+- INCOMPLETE: Response lacks expected information
+- INACCURATE: Response contains factual errors
+- POOR_TONE: Inappropriate or unprofessional tone
+- OFF_TOPIC: Response doesn't address the question
+- TOO_VERBOSE: Unnecessarily long response
+- TOO_BRIEF: Insufficiently detailed response
+- HELPFUL: Positive feedback marker
+- EXCELLENT: Exceptionally good response
+"""
+
+from enum import Enum
+from typing import Any
+
+from pydantic import Field
+
+from ..core import CoreModel
+
+
+class FeedbackCategory(str, Enum):
+    """Predefined feedback categories (system-defined)."""
+
+    # Negative categories
+    INCOMPLETE = "incomplete"
+    INACCURATE = "inaccurate"
+    POOR_TONE = "poor_tone"
+    OFF_TOPIC = "off_topic"
+    TOO_VERBOSE = "too_verbose"
+    TOO_BRIEF = "too_brief"
+    CONFUSING = "confusing"
+    UNSAFE = "unsafe"
+
+    # Positive categories
+    HELPFUL = "helpful"
+    EXCELLENT = "excellent"
+    ACCURATE = "accurate"
+    WELL_WRITTEN = "well_written"
+
+    # Neutral/Other
+    OTHER = "other"
+
+
+class Feedback(CoreModel):
+    """
+    User feedback on a message or session.
+
+    Captures structured feedback including:
+    - Rating (1-5 scale or thumbs up/down)
+    - Categories (predefined or custom)
+    - Free-text comment
+    - Trace reference for OTEL/Phoenix integration
+
+    The feedback can be attached to:
+    - A specific message (message_id set)
+    - An entire session (session_id set, message_id null)
+    """
+
+    # Target reference (at least one required)
+    session_id: str = Field(
+        ...,
+        description="Session ID this feedback relates to",
+    )
+    message_id: str | None = Field(
+        default=None,
+        description="Specific message ID (null for session-level feedback)",
+    )
+
+    # Rating (flexible: 1-5, or -1/1 for thumbs)
+    rating: int | None = Field(
+        default=None,
+        ge=-1,
+        le=5,
+        description="Rating: -1 (thumbs down), 1 (thumbs up), or 1-5 scale",
+    )
+
+    # Categories (can select multiple)
+    categories: list[str] = Field(
+        default_factory=list,
+        description="Selected feedback categories (from FeedbackCategory or custom)",
+    )
+
+    # Free-text comment
+    comment: str | None = Field(
+        default=None,
+        description="Optional free-text feedback comment",
+    )
+
+    # Trace reference for OTEL/Phoenix integration
+    trace_id: str | None = Field(
+        default=None,
+        description="OTEL trace ID for linking to observability",
+    )
+    span_id: str | None = Field(
+        default=None,
+        description="OTEL span ID for specific span feedback",
+    )
+
+    # Phoenix annotation status
+    phoenix_synced: bool = Field(
+        default=False,
+        description="Whether feedback has been synced to Phoenix as annotation",
+    )
+    phoenix_annotation_id: str | None = Field(
+        default=None,
+        description="Phoenix annotation ID after sync",
+    )
+
+    # Annotator info
+    annotator_kind: str = Field(
+        default="HUMAN",
+        description="Annotator type: HUMAN, LLM, CODE",
+    )

rem/models/entities/message.py

@@ -6,6 +6,11 @@ that can be grouped into conversations or moments.
 
 Messages are simpler than Resources but share the same graph connectivity
 through CoreModel inheritance.
+
+Trace Integration:
+- trace_id: OTEL trace ID for linking to observability
+- span_id: OTEL span ID for specific span reference
+- These enable feedback to be attached to Phoenix annotations
 """
 
 from pydantic import Field
@@ -19,6 +24,9 @@ class Message(CoreModel):
 
     Represents individual messages in conversations, chats, or other
     communication contexts. Tenant isolation is provided via CoreModel.tenant_id field.
+
+    Trace fields (trace_id, span_id) enable integration with OTEL/Phoenix
+    for observability and feedback annotation.
     """
 
     content: str = Field(
@@ -27,9 +35,30 @@ class Message(CoreModel):
     )
     message_type: str | None = Field(
         default=None,
-        description="Message type e.g role",
+        description="Message type e.g. role: 'user', 'assistant', 'system', 'tool'",
     )
     session_id: str | None = Field(
         default=None,
         description="Session identifier for tracking message context",
     )
+    prompt: str | None = Field(
+        default=None,
+        description="Custom prompt used for this message (if overridden from default)",
+    )
+    model: str | None = Field(
+        default=None,
+        description="Model used for generating this message (provider:model format)",
+    )
+    token_count: int | None = Field(
+        default=None,
+        description="Token count for this message",
+    )
+    # OTEL/Phoenix trace integration
+    trace_id: str | None = Field(
+        default=None,
+        description="OTEL trace ID for observability integration",
+    )
+    span_id: str | None = Field(
+        default=None,
+        description="OTEL span ID for specific span reference",
+    )

rem/models/entities/session.py

@@ -0,0 +1,83 @@
+"""
+Session - Conversation sessions in REM.
+
+Sessions group related messages together and can have different modes:
+- normal: Standard conversation session
+- evaluation: For LLM evaluation, stores original trace and overridden settings
+
+Sessions allow overriding settings like model, temperature, and custom prompts
+for evaluation and experimentation purposes.
+"""
+
+from enum import Enum
+
+from pydantic import Field
+
+from ..core import CoreModel
+
+
+class SessionMode(str, Enum):
+    """Session mode types."""
+
+    NORMAL = "normal"
+    EVALUATION = "evaluation"
+
+
+class Session(CoreModel):
+    """
+    Conversation session container.
+
+    Groups messages together and supports different modes for normal conversations
+    and evaluation/experimentation scenarios.
+
+    For evaluation sessions, stores:
+    - original_trace_id: Reference to the original session being evaluated
+    - settings_overrides: Model, temperature, prompt overrides
+    - prompt: Custom prompt being tested
+
+    Default sessions are lightweight - just a session_id on messages.
+    Special sessions store additional metadata for experiments.
+    """
+
+    name: str = Field(
+        ...,
+        description="Session name/identifier",
+        json_schema_extra={"entity_key": True},
+    )
+    mode: SessionMode = Field(
+        default=SessionMode.NORMAL,
+        description="Session mode: 'normal' or 'evaluation'",
+    )
+    description: str | None = Field(
+        default=None,
+        description="Optional session description",
+    )
+    # Evaluation-specific fields
+    original_trace_id: str | None = Field(
+        default=None,
+        description="For evaluation mode: ID of the original session/trace being evaluated",
+    )
+    settings_overrides: dict | None = Field(
+        default=None,
+        description="Settings overrides (model, temperature, max_tokens, system_prompt)",
+    )
+    prompt: str | None = Field(
+        default=None,
+        description="Custom prompt for this session (can override agent prompt)",
+    )
+    # Agent context
+    agent_schema_uri: str | None = Field(
+        default=None,
+        description="Agent schema used for this session",
+    )
+    # Summary stats (updated as session progresses)
+    message_count: int = Field(
+        default=0,
+        description="Number of messages in this session",
+    )
+    total_tokens: int | None = Field(
+        default=None,
+        description="Total tokens used in this session",
+    )
+
+    model_config = {"use_enum_values": True}