Fix fastmcp deprecation warning by moving log_level to run() method

groksrc · groksrc · commit fd44d657f49b · 2025-06-19T14:28:30.000-05:00
- Remove log_level from FastMCP constructor in server.py
- Add log_level='DEBUG' to mcp_server.run() calls in mcp.py
- Fixes deprecation warning that appeared when running 'bm --version'
- Follows fastmcp recommendation to provide log_level when calling run()
diff --git a/src/basic_memory/cli/commands/mcp.py b/src/basic_memory/cli/commands/mcp.py
@@ -78,11 +78,13 @@ def run_file_sync():
     if transport == "stdio":
         mcp_server.run(
             transport=transport,
+            log_level="DEBUG",
         )
     elif transport == "streamable-http" or transport == "sse":
         mcp_server.run(
             transport=transport,
             host=host,
             port=port,
             path=path,
+            log_level="DEBUG",
         )
diff --git a/src/basic_memory/db.py b/src/basic_memory/db.py
@@ -95,11 +95,12 @@ async def get_or_create_db(
 
     if _engine is None:
         _engine, _session_maker = _create_engine_and_session(db_path, db_type)
-        
+
         # Run migrations automatically unless explicitly disabled
         if ensure_migrations:
             if app_config is None:
                 from basic_memory.config import app_config as global_app_config
+
                 app_config = global_app_config
             await run_migrations(app_config, db_type)
 
@@ -170,12 +171,12 @@ async def run_migrations(
 ):  # pragma: no cover
     """Run any pending alembic migrations."""
     global _migrations_completed
-    
+
     # Skip if migrations already completed unless forced
     if _migrations_completed and not force:
         logger.debug("Migrations already completed in this session, skipping")
         return
-        
+
     logger.info("Running database migrations...")
     try:
         # Get the absolute path to the alembic directory relative to this file
@@ -206,7 +207,7 @@ async def run_migrations(
         # initialize the search Index schema
         # the project_id is not used for init_search_index, so we pass a dummy value
         await SearchRepository(session_maker, 1).init_search_index()
-        
+
         # Mark migrations as completed
         _migrations_completed = True
     except Exception as e:  # pragma: no cover
diff --git a/src/basic_memory/mcp/server.py b/src/basic_memory/mcp/server.py
@@ -105,6 +105,5 @@ def create_auth_config() -> tuple[AuthSettings | None, Any | None]:
 # Create the shared server instance
 mcp = FastMCP(
     name="Basic Memory",
-    log_level="DEBUG",
     auth=auth_provider,
 )
diff --git a/src/basic_memory/repository/entity_repository.py b/src/basic_memory/repository/entity_repository.py
@@ -102,44 +102,43 @@ async def find_by_permalinks(self, permalinks: List[str]) -> Sequence[Entity]:
 
     async def upsert_entity(self, entity: Entity) -> Entity:
         """Insert or update entity using a hybrid approach.
-        
+
         This method provides a cleaner alternative to the try/catch approach
-        for handling permalink and file_path conflicts. It first tries direct 
+        for handling permalink and file_path conflicts. It first tries direct
         insertion, then handles conflicts intelligently.
-        
+
         Args:
             entity: The entity to insert or update
-            
+
         Returns:
             The inserted or updated entity
         """
 
         async with db.scoped_session(self.session_maker) as session:
             # Set project_id if applicable and not already set
             self._set_project_id_if_needed(entity)
-            
+
             # Check for existing entity with same file_path first
             existing_by_path = await session.execute(
                 select(Entity).where(
-                    Entity.file_path == entity.file_path,
-                    Entity.project_id == entity.project_id
+                    Entity.file_path == entity.file_path, Entity.project_id == entity.project_id
                 )
             )
             existing_path_entity = existing_by_path.scalar_one_or_none()
-            
+
             if existing_path_entity:
                 # Update existing entity with same file path
                 for key, value in {
-                    'title': entity.title,
-                    'entity_type': entity.entity_type,
-                    'entity_metadata': entity.entity_metadata,
-                    'content_type': entity.content_type,
-                    'permalink': entity.permalink,
-                    'checksum': entity.checksum,
-                    'updated_at': entity.updated_at,
+                    "title": entity.title,
+                    "entity_type": entity.entity_type,
+                    "entity_metadata": entity.entity_metadata,
+                    "content_type": entity.content_type,
+                    "permalink": entity.permalink,
+                    "checksum": entity.checksum,
+                    "updated_at": entity.updated_at,
                 }.items():
                     setattr(existing_path_entity, key, value)
-                
+
                 await session.flush()
                 # Return with relationships loaded
                 query = (
@@ -150,15 +149,17 @@ async def upsert_entity(self, entity: Entity) -> Entity:
                 result = await session.execute(query)
                 found = result.scalar_one_or_none()
                 if not found:  # pragma: no cover
-                    raise RuntimeError(f"Failed to retrieve entity after update: {entity.file_path}")
+                    raise RuntimeError(
+                        f"Failed to retrieve entity after update: {entity.file_path}"
+                    )
                 return found
-            
+
             # No existing entity with same file_path, try insert
             try:
                 # Simple insert for new entity
                 session.add(entity)
                 await session.flush()
-                
+
                 # Return with relationships loaded
                 query = (
                     select(Entity)
@@ -168,36 +169,37 @@ async def upsert_entity(self, entity: Entity) -> Entity:
                 result = await session.execute(query)
                 found = result.scalar_one_or_none()
                 if not found:  # pragma: no cover
-                    raise RuntimeError(f"Failed to retrieve entity after insert: {entity.file_path}")
+                    raise RuntimeError(
+                        f"Failed to retrieve entity after insert: {entity.file_path}"
+                    )
                 return found
-                
+
             except IntegrityError:
                 # Could be either file_path or permalink conflict
                 await session.rollback()
-                
+
                 # Check if it's a file_path conflict (race condition)
                 existing_by_path_check = await session.execute(
                     select(Entity).where(
-                        Entity.file_path == entity.file_path,
-                        Entity.project_id == entity.project_id
+                        Entity.file_path == entity.file_path, Entity.project_id == entity.project_id
                     )
                 )
                 race_condition_entity = existing_by_path_check.scalar_one_or_none()
-                
+
                 if race_condition_entity:
                     # Race condition: file_path conflict detected after our initial check
                     # Update the existing entity instead
                     for key, value in {
-                        'title': entity.title,
-                        'entity_type': entity.entity_type,
-                        'entity_metadata': entity.entity_metadata,
-                        'content_type': entity.content_type,
-                        'permalink': entity.permalink,
-                        'checksum': entity.checksum,
-                        'updated_at': entity.updated_at,
+                        "title": entity.title,
+                        "entity_type": entity.entity_type,
+                        "entity_metadata": entity.entity_metadata,
+                        "content_type": entity.content_type,
+                        "permalink": entity.permalink,
+                        "checksum": entity.checksum,
+                        "updated_at": entity.updated_at,
                     }.items():
                         setattr(race_condition_entity, key, value)
-                    
+
                     await session.flush()
                     # Return the updated entity with relationships loaded
                     query = (
@@ -208,7 +210,9 @@ async def upsert_entity(self, entity: Entity) -> Entity:
                     result = await session.execute(query)
                     found = result.scalar_one_or_none()
                     if not found:  # pragma: no cover
-                        raise RuntimeError(f"Failed to retrieve entity after race condition update: {entity.file_path}")
+                        raise RuntimeError(
+                            f"Failed to retrieve entity after race condition update: {entity.file_path}"
+                        )
                     return found
                 else:
                     # Must be permalink conflict - generate unique permalink
@@ -218,26 +222,25 @@ async def _handle_permalink_conflict(self, entity: Entity, session: AsyncSession
         """Handle permalink conflicts by generating a unique permalink."""
         base_permalink = entity.permalink
         suffix = 1
-        
+
         # Find a unique permalink
         while True:
             test_permalink = f"{base_permalink}-{suffix}"
             existing = await session.execute(
                 select(Entity).where(
-                    Entity.permalink == test_permalink,
-                    Entity.project_id == entity.project_id
+                    Entity.permalink == test_permalink, Entity.project_id == entity.project_id
                 )
             )
             if existing.scalar_one_or_none() is None:
                 # Found unique permalink
                 entity.permalink = test_permalink
                 break
             suffix += 1
-            
+
         # Insert with unique permalink (no conflict possible now)
         session.add(entity)
         await session.flush()
-        
+
         # Return the inserted entity with relationships loaded
         query = (
             select(Entity)
diff --git a/src/basic_memory/services/entity_service.py b/src/basic_memory/services/entity_service.py
@@ -302,15 +302,15 @@ async def create_entity_from_markdown(
 
         Creates the entity with null checksum to indicate sync not complete.
         Relations will be added in second pass.
-        
+
         Uses UPSERT approach to handle permalink/file_path conflicts cleanly.
         """
         logger.debug(f"Creating entity: {markdown.frontmatter.title} file_path: {file_path}")
         model = entity_model_from_markdown(file_path, markdown)
 
         # Mark as incomplete because we still need to add relations
         model.checksum = None
-        
+
         # Use UPSERT to handle conflicts cleanly
         try:
             return await self.repository.upsert_entity(model)
diff --git a/src/basic_memory/services/initialization.py b/src/basic_memory/services/initialization.py
@@ -21,9 +21,9 @@ async def initialize_database(app_config: BasicMemoryConfig) -> None:
 
     Args:
         app_config: The Basic Memory project configuration
-        
+
     Note:
-        Database migrations are now handled automatically when the database 
+        Database migrations are now handled automatically when the database
         connection is first established via get_or_create_db().
     """
     # Trigger database initialization and migrations by getting the database connection
@@ -50,7 +50,9 @@ async def reconcile_projects_with_config(app_config: BasicMemoryConfig):
 
     # Get database session - migrations handled centrally
     _, session_maker = await db.get_or_create_db(
-        db_path=app_config.database_path, db_type=db.DatabaseType.FILESYSTEM, ensure_migrations=False
+        db_path=app_config.database_path,
+        db_type=db.DatabaseType.FILESYSTEM,
+        ensure_migrations=False,
     )
     project_repository = ProjectRepository(session_maker)
 
@@ -71,7 +73,9 @@ async def reconcile_projects_with_config(app_config: BasicMemoryConfig):
 async def migrate_legacy_projects(app_config: BasicMemoryConfig):
     # Get database session - migrations handled centrally
     _, session_maker = await db.get_or_create_db(
-        db_path=app_config.database_path, db_type=db.DatabaseType.FILESYSTEM, ensure_migrations=False
+        db_path=app_config.database_path,
+        db_type=db.DatabaseType.FILESYSTEM,
+        ensure_migrations=False,
     )
     logger.info("Migrating legacy projects...")
     project_repository = ProjectRepository(session_maker)
@@ -140,7 +144,9 @@ async def initialize_file_sync(
 
     # Load app configuration - migrations handled centrally
     _, session_maker = await db.get_or_create_db(
-        db_path=app_config.database_path, db_type=db.DatabaseType.FILESYSTEM, ensure_migrations=False
+        db_path=app_config.database_path,
+        db_type=db.DatabaseType.FILESYSTEM,
+        ensure_migrations=False,
     )
     project_repository = ProjectRepository(session_maker)
 
diff --git a/tests/mcp/test_tool_write_note.py b/tests/mcp/test_tool_write_note.py
@@ -418,59 +418,53 @@ async def test_write_note_preserves_content_frontmatter(app):
 @pytest.mark.asyncio
 async def test_write_note_permalink_collision_fix_issue_139(app):
     """Test fix for GitHub Issue #139: UNIQUE constraint failed: entity.permalink.
-    
+
     This reproduces the exact scenario described in the issue:
-    1. Create a note with title "Note 1" 
+    1. Create a note with title "Note 1"
     2. Create another note with title "Note 2"
     3. Try to create/replace first note again with same title "Note 1"
-    
+
     Before the fix, step 3 would fail with UNIQUE constraint error.
     After the fix, it should either update the existing note or create with unique permalink.
     """
     # Step 1: Create first note
     result1 = await write_note.fn(
-        title="Note 1",
-        folder="test",
-        content="Original content for note 1"
+        title="Note 1", folder="test", content="Original content for note 1"
     )
     assert "# Created note" in result1
     assert "permalink: test/note-1" in result1
-    
+
     # Step 2: Create second note with different title
-    result2 = await write_note.fn(
-        title="Note 2", 
-        folder="test",
-        content="Content for note 2"
-    )
+    result2 = await write_note.fn(title="Note 2", folder="test", content="Content for note 2")
     assert "# Created note" in result2
     assert "permalink: test/note-2" in result2
-    
+
     # Step 3: Try to create/replace first note again
     # This scenario would trigger the UNIQUE constraint failure before the fix
     result3 = await write_note.fn(
         title="Note 1",  # Same title as first note
-        folder="test",   # Same folder as first note
-        content="Replacement content for note 1"  # Different content
+        folder="test",  # Same folder as first note
+        content="Replacement content for note 1",  # Different content
     )
-    
+
     # This should not raise a UNIQUE constraint failure error
     # It should succeed and either:
     # 1. Update the existing note (preferred behavior)
     # 2. Create a new note with unique permalink (fallback behavior)
-    
+
     assert result3 is not None
-    assert ("Updated note" in result3 or "Created note" in result3)
-    
+    assert "Updated note" in result3 or "Created note" in result3
+
     # The result should contain either the original permalink or a unique one
-    assert ("permalink: test/note-1" in result3 or "permalink: test/note-1-1" in result3)
-    
+    assert "permalink: test/note-1" in result3 or "permalink: test/note-1-1" in result3
+
     # Verify we can read back the content
     if "permalink: test/note-1" in result3:
         # Updated existing note case
         content = await read_note.fn("test/note-1")
         assert "Replacement content for note 1" in content
     else:
-        # Created new note with unique permalink case  
+        # Created new note with unique permalink case
         content = await read_note.fn("test/note-1-1")
         assert "Replacement content for note 1" in content
         # Original note should still exist
diff --git a/tests/repository/test_entity_repository_upsert.py b/tests/repository/test_entity_repository_upsert.py
diff --git a/tests/test_db_migration_deduplication.py b/tests/test_db_migration_deduplication.py

Original file line number	Diff line number	Diff line change
`@@ -78,11 +78,13 @@ def run_file_sync():`
`78`	`78`	`if transport == "stdio":`
`79`	`79`	`mcp_server.run(`
`80`	`80`	`transport=transport,`
	`81`	`+ log_level="DEBUG",`
`81`	`82`	`)`
`82`	`83`	`elif transport == "streamable-http" or transport == "sse":`
`83`	`84`	`mcp_server.run(`
`84`	`85`	`transport=transport,`
`85`	`86`	`host=host,`
`86`	`87`	`port=port,`
`87`	`88`	`path=path,`
	`89`	`+ log_level="DEBUG",`
`88`	`90`	`)`
Original file line number	Diff line number	Diff line change
`@@ -105,6 +105,5 @@ def create_auth_config() -> tuple[AuthSettings \| None, Any \| None]:`
`105`	`105`	`# Create the shared server instance`
`106`	`106`	`mcp = FastMCP(`
`107`	`107`	`name="Basic Memory",`
`108`		`- log_level="DEBUG",`
`109`	`108`	`auth=auth_provider,`
`110`	`109`	`)`