/docs#

mem0core/app.py

@@ -2,11 +2,12 @@ from fastapi import FastAPI
 
 from .memory_factory import build_memories
 from .routes import build_router
+from .tags import TAGS_METADATA
 
 
 def create_app() -> FastAPI:
     """Create the FastAPI app and register all mem0 server routes."""
-    app = FastAPI(title="mem0 server")
+    app = FastAPI(title="mem0 server", openapi_tags=TAGS_METADATA)
     memory_conv, memory_know = build_memories()
     app.include_router(build_router(memory_conv, memory_know))
     return app

mem0core/routes.py

@@ -17,12 +17,12 @@ def build_router(memory_conv: Memory, memory_know: Memory) -> APIRouter:
     with open("dashboard.html", "r", encoding="utf-8") as handle:
         dashboard_html = handle.read()
 
-    @router.get("/dashboard", response_class=HTMLResponse, summary="Render dashboard")
+    @router.get("/dashboard", response_class=HTMLResponse, summary="Render dashboard", tags=["dashboard"])
     async def dashboard():
         """Serve the local dashboard HTML used for memory inspection and admin actions."""
         return HTMLResponse(content=dashboard_html)
 
-    @router.get("/health", summary="Service health and prompt preview")
+    @router.get("/health", summary="Service health and prompt preview", tags=["health"])
     async def health():
         """Return runtime health plus prompt snippets for quick configuration verification."""
         return SafeJSONResponse(
@@ -40,28 +40,28 @@ def build_router(memory_conv: Memory, memory_know: Memory) -> APIRouter:
             }
         )
 
-    @router.post("/memories", summary="Add conversational memory")
+    @router.post("/memories", summary="Add conversational memory", tags=["memories"])
     async def add_memory(req: Request):
         """Store conversational memory with LLM extraction and deduplication enabled."""
         return await handle_add(req, memory_conv, verbatim_allowed=False)
 
-    @router.post("/memories/search", summary="Search conversational memory")
+    @router.post("/memories/search", summary="Search conversational memory", tags=["memories"])
     async def search_memories(req: Request):
         """Search conversational memory and rerank candidates by relevance."""
         return await handle_search(req, memory_conv)
 
-    @router.post("/memories/recent", summary="Recent conversational memory")
+    @router.post("/memories/recent", summary="Recent conversational memory", tags=["memories"])
     async def recent_memories(req: Request):
         """Return newest conversational memories ordered by creation time."""
         return await handle_recent(req, memory_conv)
 
-    @router.delete("/memories", summary="Delete conversational memory by filter")
+    @router.delete("/memories", summary="Delete conversational memory by filter", tags=["memories"])
     async def delete_memory(req: Request):
         """Delete conversational memories using a mem0 filter object from the request body."""
         data = await req.json()
         return SafeJSONResponse(content=memory_conv.delete(data.get("filter", {})))
 
-    @router.post("/memories/all", summary="List all conversational memories")
+    @router.post("/memories/all", summary="List all conversational memories", tags=["memories"])
     async def memories_all(req: Request):
         """Fetch full conversational history for a user by paging Chroma directly."""
         data = await req.json()
@@ -89,28 +89,28 @@ def build_router(memory_conv: Memory, memory_know: Memory) -> APIRouter:
         print(f"[memories/all] user={user_id} total={len(items)}")
         return SafeJSONResponse(content={"results": items})
 
-    @router.post("/knowledge", summary="Add knowledge chunk")
+    @router.post("/knowledge", summary="Add knowledge chunk", tags=["knowledge"])
     async def add_knowledge(req: Request):
         """Store knowledge verbatim without LLM extraction (ingestor already summarizes)."""
         return await handle_add(req, memory_know, verbatim_allowed=True)
 
-    @router.post("/knowledge/search", summary="Search knowledge base")
+    @router.post("/knowledge/search", summary="Search knowledge base", tags=["knowledge"])
     async def search_knowledge(req: Request):
         """Search knowledge memories and rerank candidates."""
         return await handle_search(req, memory_know)
 
-    @router.post("/knowledge/recent", summary="Recent knowledge entries")
+    @router.post("/knowledge/recent", summary="Recent knowledge entries", tags=["knowledge"])
     async def recent_knowledge(req: Request):
         """Return newest knowledge entries for a user."""
         return await handle_recent(req, memory_know)
 
-    @router.delete("/knowledge", summary="Delete knowledge by filter")
+    @router.delete("/knowledge", summary="Delete knowledge by filter", tags=["knowledge"])
     async def delete_knowledge(req: Request):
         """Delete knowledge entries using a mem0 filter object from the request body."""
         data = await req.json()
         return SafeJSONResponse(content=memory_know.delete(data.get("filter", {})))
 
-    @router.post("/knowledge/sources", summary="Knowledge source counts")
+    @router.post("/knowledge/sources", summary="Knowledge source counts", tags=["knowledge"])
     async def knowledge_sources(req: Request):
         """List distinct source_file values with counts, bypassing mem0 get_all caps."""
         data = await req.json()
@@ -126,7 +126,7 @@ def build_router(memory_conv: Memory, memory_know: Memory) -> APIRouter:
         print(f"[sources] user={user_id} total={len(rows)} books={len(sources)}")
         return SafeJSONResponse(content={"sources": sources, "total": len(rows)})
 
-    @router.delete("/knowledge/by-source", summary="Delete all entries for one source file")
+    @router.delete("/knowledge/by-source", summary="Delete all entries for one source file", tags=["knowledge"])
     async def delete_knowledge_by_source(req: Request):
         """Delete all knowledge entries for a source_file from Chroma and SQLite."""
         data = await req.json()
@@ -162,7 +162,7 @@ def build_router(memory_conv: Memory, memory_know: Memory) -> APIRouter:
             }
         )
 
-    @router.delete("/memory/{memory_id}", summary="Delete one memory by ID")
+    @router.delete("/memory/{memory_id}", summary="Delete one memory by ID", tags=["memories", "knowledge"])
     async def delete_single_memory(memory_id: str, req: Request):
         """Delete a single memory from selected collection and mirror deletion in SQLite."""
         data = await req.json()
@@ -178,7 +178,7 @@ def build_router(memory_conv: Memory, memory_know: Memory) -> APIRouter:
         print(f"[delete single] id={memory_id} collection={collection}")
         return SafeJSONResponse(content={"deleted": memory_id})
 
-    @router.post("/search", summary="Search both collections")
+    @router.post("/search", summary="Search both collections", tags=["search"])
     async def search_all(req: Request):
         """Search conversational + knowledge collections, then rerank merged results."""
         data = await req.json()

mem0core/tags.py

@@ -0,0 +1,22 @@
+TAGS_METADATA = [
+    {
+        "name": "dashboard",
+        "description": "Admin dashboard and static assets",
+    },
+    {
+        "name": "health",
+        "description": "Service diagnostics and prompt previews",
+    },
+    {
+        "name": "memories",
+        "description": "Conversational memory CRUD operations used by OpenClaw",
+    },
+    {
+        "name": "knowledge",
+        "description": "Knowledge-base ingestion, search, and housekeeping",
+    },
+    {
+        "name": "search",
+        "description": "Merged search across both memory collections",
+    },
+]