update main with changes

src/basic_memory/api/app.py

@@ -5,17 +5,15 @@ from loguru import logger
 
 from .routers import knowledge
 
-
 # Initialize FastAPI app
 app = FastAPI(
-    title="Basic Memory API",
-    description="Knowledge graph API for basic-memory",
-    version="0.1.0"
+    title="Basic Memory API", description="Knowledge graph API for basic-memory", version="0.1.0"
 )
 
 # Include routers
 app.include_router(knowledge.router)
 
+
 # Add startup event
 @app.on_event("startup")
 async def startup_event():

src/basic_memory/api/routers/__init__.py

@@ -1,4 +1,5 @@
 """API routers."""
+
 from . import knowledge
 
-__all__ = ["knowledge"]
+__all__ = ["knowledge"]

src/basic_memory/api/routers/knowledge.py

@@ -1,8 +1,9 @@
 """Router for knowledge graph operations."""
 
 from fastapi import APIRouter, HTTPException
+from loguru import logger
 
-from basic_memory.deps import MemoryServiceDep
+from basic_memory.deps import EntityServiceDep, RelationServiceDep, ObservationServiceDep
 from basic_memory.fileio import EntityNotFoundError
 from basic_memory.schemas import (
     CreateEntityRequest,
@@ -24,7 +25,6 @@ from basic_memory.schemas import (
     AddObservationsResponse,
     RelationResponse,
     DeleteEntityRequest,
-    Entity,
 )
 
 router = APIRouter(prefix="/knowledge", tags=["knowledge"])
@@ -34,10 +34,10 @@ router = APIRouter(prefix="/knowledge", tags=["knowledge"])
 
 @router.post("/entities", response_model=CreateEntityResponse)
 async def create_entities(
-    data: CreateEntityRequest, memory_service: MemoryServiceDep
+    data: CreateEntityRequest, entity_service: EntityServiceDep
 ) -> CreateEntityResponse:
     """Create new entities in the knowledge graph."""
-    entities = await memory_service.create_entities(data.entities)
+    entities = await entity_service.create_entities(data.entities)
     return CreateEntityResponse(
         entities=[EntityResponse.model_validate(entity) for entity in entities]
     )
@@ -45,10 +45,10 @@ async def create_entities(
 
 @router.post("/relations", response_model=CreateRelationsResponse)
 async def create_relations(
-    data: CreateRelationsRequest, memory_service: MemoryServiceDep
+    data: CreateRelationsRequest, relation_service: RelationServiceDep
 ) -> CreateRelationsResponse:
     """Create relations between entities."""
-    relations = await memory_service.create_relations(data.relations)
+    relations = await relation_service.create_relations(data.relations)
     return CreateRelationsResponse(
         relations=[RelationResponse.model_validate(relation) for relation in relations]
     )
@@ -56,10 +56,11 @@ async def create_relations(
 
 @router.post("/observations", response_model=AddObservationsResponse)
 async def add_observations(
-    data: AddObservationsRequest, memory_service: MemoryServiceDep
+    data: AddObservationsRequest, observation_service: ObservationServiceDep
 ) -> AddObservationsResponse:
     """Add observations to an entity."""
-    observations = await memory_service.add_observations(data)
+    logger.debug(f"Adding observations to entity: {data.entity_id}")
+    observations = await observation_service.add_observations(data.entity_id, data.observations)
     return AddObservationsResponse(
         entity_id=data.entity_id,
         observations=[
@@ -72,10 +73,10 @@ async def add_observations(
 
 
 @router.get("/entities/{entity_id:path}", response_model=EntityResponse)
-async def get_entity(entity_id: str, memory_service: MemoryServiceDep) -> EntityResponse:
+async def get_entity(entity_id: str, entity_service: EntityServiceDep) -> EntityResponse:
     """Get a specific entity by ID."""
     try:
-        entity = await memory_service.get_entity(entity_id)
+        entity = await entity_service.get_entity(entity_id)
         return EntityResponse.model_validate(entity)
     except EntityNotFoundError:
         raise HTTPException(status_code=404, detail=f"Entity {entity_id} not found")
@@ -83,20 +84,25 @@ async def get_entity(entity_id: str, memory_service: MemoryServiceDep) -> Entity
 
 @router.post("/search", response_model=SearchNodesResponse)
 async def search_nodes(
-    data: SearchNodesRequest, memory_service: MemoryServiceDep
+    data: SearchNodesRequest, entity_service: EntityServiceDep
 ) -> SearchNodesResponse:
     """Search for entities in the knowledge graph."""
-    matches = await memory_service.search_nodes(data.query)
+    logger.debug(f"Searching nodes with query: {data.query}")
+    matches = await entity_service.search(data.query)
+    logger.debug(f"Found {len(matches)} matches for '{data.query}'")
+
     return SearchNodesResponse(
         matches=[EntityResponse.model_validate(entity) for entity in matches], query=data.query
     )
 
 
 @router.post("/nodes", response_model=OpenNodesResponse)
-async def open_nodes(data: OpenNodesRequest, memory_service: MemoryServiceDep) -> OpenNodesResponse:
+async def open_nodes(data: OpenNodesRequest, entity_service: EntityServiceDep) -> OpenNodesResponse:
     """Open specific nodes by their names."""
-    entities = await memory_service.open_nodes(data.entity_ids)
-    return OpenNodesResponse(entities=[Entity.model_validate(entity) for entity in entities])
+    entities = await entity_service.open_nodes(data.entity_ids)
+    return OpenNodesResponse(
+        entities=[EntityResponse.model_validate(entity) for entity in entities]
+    )
 
 
 ## Delete endpoints
@@ -104,26 +110,26 @@ async def open_nodes(data: OpenNodesRequest, memory_service: MemoryServiceDep) -
 
 @router.post("/entities/delete", response_model=DeleteEntityResponse)
 async def delete_entity(
-    data: DeleteEntityRequest, memory_service: MemoryServiceDep
+    data: DeleteEntityRequest, entity_service: EntityServiceDep
 ) -> DeleteEntityResponse:
     """Delete a specific entity by ID."""
-    deleted = await memory_service.delete_entities(data.entity_ids)
+    deleted = await entity_service.delete_entities(data.entity_ids)
     return DeleteEntityResponse(deleted=deleted)
 
 
 @router.post("/observations/delete", response_model=DeleteObservationsResponse)
 async def delete_observations(
-    data: DeleteObservationsRequest, memory_service: MemoryServiceDep
+    data: DeleteObservationsRequest, observation_service: ObservationServiceDep
 ) -> DeleteObservationsResponse:
     """Delete observations from an entity."""
     entity_id = data.entity_id
-    deleted = await memory_service.delete_observations(entity_id, data.deletions)
+    deleted = await observation_service.delete_observations(entity_id, data.deletions)
     return DeleteObservationsResponse(deleted=deleted)
 
 
 @router.post("/relations/delete", response_model=DeleteRelationsResponse)
 async def delete_relations(
-    data: DeleteRelationsRequest, memory_service: MemoryServiceDep
+    data: DeleteRelationsRequest, relation_service: RelationServiceDep
 ) -> DeleteRelationsResponse:
     """Delete relations between entities."""
     to_delete = [
@@ -134,5 +140,5 @@ async def delete_relations(
         }
         for relation in data.relations
     ]
-    deleted = await memory_service.delete_relations(to_delete)
+    deleted = await relation_service.delete_relations(to_delete)
     return DeleteRelationsResponse(deleted=deleted)