Fix: Changed keyword from assisstant to secretary (#2937)

openmemory/api/app/database.py

@@ -1,7 +1,8 @@
 import os
+
+from dotenv import load_dotenv
 from sqlalchemy import create_engine
 from sqlalchemy.orm import declarative_base, sessionmaker
-from dotenv import load_dotenv
 
 # load .env file (make sure you have DATABASE_URL set)
 load_dotenv()

openmemory/api/app/mcp_server.py

@@ -15,22 +15,22 @@ Key features:
 - Environment variable parsing for API keys
 """
 
-import logging
+import contextvars
+import datetime
 import json
-from mcp.server.fastmcp import FastMCP
-from mcp.server.sse import SseServerTransport
+import logging
+import uuid
+
+from app.database import SessionLocal
+from app.models import Memory, MemoryAccessLog, MemoryState, MemoryStatusHistory
+from app.utils.db import get_user_and_app
 from app.utils.memory import get_memory_client
+from app.utils.permissions import check_memory_access_permissions
+from dotenv import load_dotenv
 from fastapi import FastAPI, Request
 from fastapi.routing import APIRouter
-import contextvars
-import os
-from dotenv import load_dotenv
-from app.database import SessionLocal
-from app.models import Memory, MemoryState, MemoryStatusHistory, MemoryAccessLog
-from app.utils.db import get_user_and_app
-import uuid
-import datetime
-from app.utils.permissions import check_memory_access_permissions
+from mcp.server.fastmcp import FastMCP
+from mcp.server.sse import SseServerTransport
 from qdrant_client import models as qdrant_models
 
 # Load environment variables
@@ -410,32 +410,32 @@ async def handle_get_message(request: Request):
 async def handle_post_message(request: Request):
     return await handle_post_message(request)
 
-async def handle_post_message(request: Request):
-    """Handle POST messages for SSE"""
-    try:
-        body = await request.body()
+# async def handle_post_message(request: Request):
+#     """Handle POST messages for SSE"""
+#     try:
+#         body = await request.body()
 
-        # Create a simple receive function that returns the body
-        async def receive():
-            return {"type": "http.request", "body": body, "more_body": False}
+#         # Create a simple receive function that returns the body
+#         async def receive():
+#             return {"type": "http.request", "body": body, "more_body": False}
 
-        # Create a simple send function that does nothing
-        async def send(message):
-            return {}
+#         # Create a simple send function that does nothing
+#         async def send(message):
+#             return {}
 
-        # Call handle_post_message with the correct arguments
-        await sse.handle_post_message(request.scope, receive, send)
+#         # Call handle_post_message with the correct arguments
+#         await sse.handle_post_message(request.scope, receive, send)
 
-        # Return a success response
-        return {"status": "ok"}
-    finally:
-        pass
-        # Clean up context variable
-        # client_name_var.reset(client_token)
+#         # Return a success response
+#         return {"status": "ok"}
+#     finally:
+#         pass
+#         # Clean up context variable
+#         # client_name_var.reset(client_token)
 
 def setup_mcp_server(app: FastAPI):
     """Setup MCP server with the FastAPI application"""
-    mcp._mcp_server.name = f"mem0-mcp-server"
+    mcp._mcp_server.name = "mem0-mcp-server"
 
     # Include MCP router in the FastAPI app
     app.include_router(mcp_router)

openmemory/api/app/models.py

@@ -1,15 +1,25 @@
+import datetime
 import enum
 import uuid
-import datetime
+
 import sqlalchemy as sa
-from sqlalchemy import (
-    Column, String, Boolean, ForeignKey, Enum, Table,
-    DateTime, JSON, Integer, UUID, Index, event
-)
-from sqlalchemy.orm import relationship
 from app.database import Base
-from sqlalchemy.orm import Session
 from app.utils.categorization import get_categories_for_memory
+from sqlalchemy import (
+    JSON,
+    UUID,
+    Boolean,
+    Column,
+    DateTime,
+    Enum,
+    ForeignKey,
+    Index,
+    Integer,
+    String,
+    Table,
+    event,
+)
+from sqlalchemy.orm import Session, relationship
 
 
 def get_current_utc_time():

openmemory/api/app/routers/__init__.py

@@ -1,6 +1,6 @@
-from .memories import router as memories_router
 from .apps import router as apps_router
-from .stats import router as stats_router
 from .config import router as config_router
+from .memories import router as memories_router
+from .stats import router as stats_router
 
-__all__ = ["memories_router", "apps_router", "stats_router", "config_router"]
+__all__ = ["memories_router", "apps_router", "stats_router", "config_router"]

openmemory/api/app/routers/apps.py

@@ -1,11 +1,11 @@
 from typing import Optional
 from uuid import UUID
-from fastapi import APIRouter, Depends, HTTPException, Query
-from sqlalchemy.orm import Session, joinedload
-from sqlalchemy import func, desc
 
 from app.database import get_db
 from app.models import App, Memory, MemoryAccessLog, MemoryState
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy import desc, func
+from sqlalchemy.orm import Session, joinedload
 
 router = APIRouter(prefix="/api/v1/apps", tags=["apps"])
 

openmemory/api/app/routers/config.py

@@ -1,12 +1,11 @@
-import os
-import json
-from typing import Dict, Any, Optional
-from fastapi import APIRouter, HTTPException, Depends
-from pydantic import BaseModel, Field
-from sqlalchemy.orm import Session
+from typing import Any, Dict, Optional
+
 from app.database import get_db
 from app.models import Config as ConfigModel
 from app.utils.memory import reset_memory_client
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel, Field
+from sqlalchemy.orm import Session
 
 router = APIRouter(prefix="/api/v1/config", tags=["config"])
 

openmemory/api/app/routers/memories.py

@@ -1,23 +1,28 @@
-from datetime import datetime, UTC
-from typing import List, Optional, Set
-from uuid import UUID, uuid4
 import logging
-import os
-from fastapi import APIRouter, Depends, HTTPException, Query
-from sqlalchemy.orm import Session, joinedload
-from fastapi_pagination import Page, Params
-from fastapi_pagination.ext.sqlalchemy import paginate as sqlalchemy_paginate
-from pydantic import BaseModel
-from sqlalchemy import or_, func
-from app.utils.memory import get_memory_client
+from datetime import UTC, datetime
+from typing import List, Optional, Set
+from uuid import UUID
 
 from app.database import get_db
 from app.models import (
-    Memory, MemoryState, MemoryAccessLog, App,
-    MemoryStatusHistory, User, Category, AccessControl, Config as ConfigModel
+    AccessControl,
+    App,
+    Category,
+    Memory,
+    MemoryAccessLog,
+    MemoryState,
+    MemoryStatusHistory,
+    User,
 )
-from app.schemas import MemoryResponse, PaginatedMemoryResponse
+from app.schemas import MemoryResponse
+from app.utils.memory import get_memory_client
 from app.utils.permissions import check_memory_access_permissions
+from fastapi import APIRouter, Depends, HTTPException, Query
+from fastapi_pagination import Page, Params
+from fastapi_pagination.ext.sqlalchemy import paginate as sqlalchemy_paginate
+from pydantic import BaseModel
+from sqlalchemy import func
+from sqlalchemy.orm import Session, joinedload
 
 router = APIRouter(prefix="/api/v1/memories", tags=["memories"])
 
@@ -412,7 +417,7 @@ async def pause_memories(
         ).all()
         for memory in memories:
             update_memory_state(db, memory.id, state, user_id)
-        return {"message": f"Successfully paused all memories"}
+        return {"message": "Successfully paused all memories"}
 
     if memory_ids:
         # Pause specific memories

openmemory/api/app/routers/stats.py

@@ -1,8 +1,7 @@
+from app.database import get_db
+from app.models import App, Memory, MemoryState, User
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
-from app.database import get_db
-from app.models import User, Memory, App, MemoryState
-
 
 router = APIRouter(prefix="/api/v1/stats", tags=["stats"])
 

openmemory/api/app/schemas.py

@@ -1,8 +1,10 @@
 from datetime import datetime
-from typing import Optional, List
+from typing import List, Optional
 from uuid import UUID
+
 from pydantic import BaseModel, Field, validator
 
+
 class MemoryBase(BaseModel):
     content: str
     metadata_: Optional[dict] = Field(default_factory=dict)

openmemory/api/app/utils/categorization.py

@@ -1,11 +1,11 @@
 import logging
 from typing import List
 
+from app.utils.prompts import MEMORY_CATEGORIZATION_PROMPT
 from dotenv import load_dotenv
 from openai import OpenAI
 from pydantic import BaseModel
 from tenacity import retry, stop_after_attempt, wait_exponential
-from app.utils.prompts import MEMORY_CATEGORIZATION_PROMPT
 
 load_dotenv()
 openai_client = OpenAI()

openmemory/api/app/utils/db.py

@@ -1,7 +1,8 @@
-from sqlalchemy.orm import Session
-from app.models import User, App
 from typing import Tuple
 
+from app.models import App, User
+from sqlalchemy.orm import Session
+
 
 def get_or_create_user(db: Session, user_id: str) -> User:
     """Get or create a user with the given user_id"""

openmemory/api/app/utils/memory.py

@@ -27,16 +27,15 @@ Example configuration that will be automatically adjusted:
 }
 """
 
-import os
-import json
 import hashlib
+import json
+import os
 import socket
-import platform
 
-from mem0 import Memory
 from app.database import SessionLocal
 from app.models import Config as ConfigModel
 
+from mem0 import Memory
 
 _memory_client = None
 _config_hash = None

openmemory/api/app/utils/permissions.py

@@ -1,7 +1,8 @@
 from typing import Optional
 from uuid import UUID
+
+from app.models import App, Memory, MemoryState
 from sqlalchemy.orm import Session
-from app.models import Memory, App, MemoryState
 
 
 def check_memory_access_permissions(