mcp-sqlite-memory-bank 1.6.0__tar.gz → 1.6.2__tar.gz

{mcp_sqlite_memory_bank-1.6.0/src/mcp_sqlite_memory_bank.egg-info → mcp_sqlite_memory_bank-1.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mcp_sqlite_memory_bank
-Version: 1.6.0
+Version: 1.6.2
 Summary: A dynamic, agent/LLM-friendly SQLite memory bank for MCP servers with semantic search capabilities.
 Author-email: Robert Meisner <robert@catchit.pl>
 License-Expression: MIT

{mcp_sqlite_memory_bank-1.6.0 → mcp_sqlite_memory_bank-1.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mcp_sqlite_memory_bank"
-version = "1.6.0"
+version = "1.6.2"
 description = "A dynamic, agent/LLM-friendly SQLite memory bank for MCP servers with semantic search capabilities."
 authors = [
     { name="Robert Meisner", email="robert@catchit.pl" }

{mcp_sqlite_memory_bank-1.6.0 → mcp_sqlite_memory_bank-1.6.2}/src/mcp_sqlite_memory_bank/__init__.py

@@ -8,7 +8,7 @@ Cursor, and other LLM-powered tools to interact with structured data in a
 safe, explicit, and extensible way.
 
 Author: Robert Meisner
-Version: 1.6.0
+Version: 1.6.2
 License: MIT
 """
 
@@ -73,7 +73,7 @@ from .types import (
 )
 
 # Package metadata
-__version__ = "0.1.0"
+__version__ = "1.6.2"
 __author__ = "Robert Meisner"
 __all__ = [
     # Core tools

{mcp_sqlite_memory_bank-1.6.0 → mcp_sqlite_memory_bank-1.6.2}/src/mcp_sqlite_memory_bank/__main__.py

@@ -11,9 +11,7 @@ import sys
 import os
 
 # Add the project root to Python path to avoid import issues
-project_root = os.path.dirname(
-    os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-)
+project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 if project_root not in sys.path:
     sys.path.insert(0, project_root)
 
@@ -34,12 +32,8 @@ def main() -> None:
             print("SQLite Memory Bank MCP Server")
             print("Usage: python -m src.mcp_sqlite_memory_bank")
             print("")
-            print(
-                "This starts the SQLite Memory Bank as an MCP (Model Context Protocol) server."
-            )
-            print(
-                "The server communicates via STDIO and provides memory management tools"
-            )
+            print("This starts the SQLite Memory Bank as an MCP (Model Context Protocol) server.")
+            print("The server communicates via STDIO and provides memory management tools")
             print("for LLMs and AI agents.")
             print("")
             print(f"Database location: {DB_PATH}")
@@ -49,9 +43,7 @@ def main() -> None:
             return
 
         # Log startup information
-        logging.info(
-            f"Starting SQLite Memory Bank MCP server with database at {DB_PATH}"
-        )
+        logging.info(f"Starting SQLite Memory Bank MCP server with database at {DB_PATH}")
 
         # Run the FastMCP app in stdio mode for MCP clients
         app.run(transport="stdio")

{mcp_sqlite_memory_bank-1.6.0 → mcp_sqlite_memory_bank-1.6.2}/src/mcp_sqlite_memory_bank/database.py

@@ -116,8 +116,7 @@ class SQLiteMemoryDatabase:
         for col_name in column_names:
             if col_name not in valid_columns:
                 raise ValidationError(
-                    f"Invalid column '{col_name}' for table "
-                    f"'{table.name}' in {context}"
+                    f"Invalid column '{col_name}' for table " f"'{table.name}' in {context}"
                 )
 
     def _build_where_conditions(self, table: Table, where: Dict[str, Any]) -> List:
@@ -152,9 +151,7 @@ class SQLiteMemoryDatabase:
 
         return decorator
 
-    def create_table(
-        self, table_name: str, columns: List[Dict[str, str]]
-    ) -> ToolResponse:
+    def create_table(self, table_name: str, columns: List[Dict[str, str]]) -> ToolResponse:
         """Create a new table with the specified columns."""
         # Input validation
         if not table_name or not table_name.isidentifier():
@@ -190,9 +187,7 @@ class SQLiteMemoryDatabase:
             with self.get_connection() as conn:
                 inspector = inspect(conn)
                 tables = [
-                    name
-                    for name in inspector.get_table_names()
-                    if not name.startswith("sqlite_")
+                    name for name in inspector.get_table_names() if not name.startswith("sqlite_")
                 ]
             return {"success": True, "tables": tables}
         except SQLAlchemyError as e:
@@ -252,9 +247,7 @@ class SQLiteMemoryDatabase:
         except (ValidationError, SQLAlchemyError) as e:
             if isinstance(e, ValidationError):
                 raise e
-            raise DatabaseError(
-                f"Failed to rename table from {old_name} to {new_name}: {str(e)}"
-            )
+            raise DatabaseError(f"Failed to rename table from {old_name} to {new_name}: {str(e)}")
 
     def insert_row(self, table_name: str, data: Dict[str, Any]) -> ToolResponse:
         """Insert a row into a table."""
@@ -330,9 +323,7 @@ class SQLiteMemoryDatabase:
                 raise e
             raise DatabaseError(f"Failed to update table {table_name}: {str(e)}")
 
-    def delete_rows(
-        self, table_name: str, where: Optional[Dict[str, Any]] = None
-    ) -> ToolResponse:
+    def delete_rows(self, table_name: str, where: Optional[Dict[str, Any]] = None) -> ToolResponse:
         """Delete rows from a table."""
         try:
             table = self._ensure_table_exists(table_name)
@@ -343,9 +334,7 @@ class SQLiteMemoryDatabase:
             if conditions:
                 stmt = stmt.where(and_(*conditions))
             else:
-                logging.warning(
-                    f"delete_rows called without WHERE clause on table {table_name}"
-                )
+                logging.warning(f"delete_rows called without WHERE clause on table {table_name}")
 
             result = self._execute_with_commit(stmt)
             return {"success": True, "rows_affected": result.rowcount}
@@ -428,8 +417,7 @@ class SQLiteMemoryDatabase:
                     text_columns = [
                         col
                         for col in table.columns
-                        if "TEXT" in str(col.type).upper()
-                        or "VARCHAR" in str(col.type).upper()
+                        if "TEXT" in str(col.type).upper() or "VARCHAR" in str(col.type).upper()
                     ]
 
                     if not text_columns:
@@ -497,10 +485,7 @@ class SQLiteMemoryDatabase:
 
                                     # Combined relevance score
                                     col_relevance = (
-                                        exact_score
-                                        + term_score
-                                        + position_bonus
-                                        + column_bonus
+                                        exact_score + term_score + position_bonus + column_bonus
                                     )
                                     relevance_scores.append(col_relevance)
 
@@ -510,9 +495,7 @@ class SQLiteMemoryDatabase:
                                         len(row_dict[col.name]),
                                         first_occurrence + len(query) + 50,
                                     )
-                                    snippet = str(row_dict[col.name])[
-                                        snippet_start:snippet_end
-                                    ]
+                                    snippet = str(row_dict[col.name])[snippet_start:snippet_end]
                                     if snippet_start > 0:
                                         snippet = "..." + snippet
                                     if snippet_end < len(str(row_dict[col.name])):
@@ -532,9 +515,7 @@ class SQLiteMemoryDatabase:
                                     "match_quality": (
                                         "high"
                                         if total_relevance > 0.5
-                                        else (
-                                            "medium" if total_relevance > 0.1 else "low"
-                                        )
+                                        else ("medium" if total_relevance > 0.1 else "low")
                                     ),
                                     "match_count": len(relevance_scores),
                                 }
@@ -571,9 +552,7 @@ class SQLiteMemoryDatabase:
             table_names = list(self.metadata.tables.keys())
 
             if pattern:
-                table_names = [
-                    name for name in table_names if pattern.replace("%", "") in name
-                ]
+                table_names = [name for name in table_names if pattern.replace("%", "") in name]
 
             exploration: Dict[str, Any] = {
                 "tables": [],
@@ -599,10 +578,7 @@ class SQLiteMemoryDatabase:
                         }
                         columns.append(col_data)
 
-                        if (
-                            "TEXT" in str(col.type).upper()
-                            or "VARCHAR" in str(col.type).upper()
-                        ):
+                        if "TEXT" in str(col.type).upper() or "VARCHAR" in str(col.type).upper():
                             text_columns.append(col.name)
 
                     table_info: Dict[str, Any] = {
@@ -613,27 +589,21 @@ class SQLiteMemoryDatabase:
 
                     # Add row count if requested
                     if include_row_counts:
-                        count_result = conn.execute(
-                            select(text("COUNT(*)")).select_from(table)
-                        )
+                        count_result = conn.execute(select(text("COUNT(*)")).select_from(table))
                         row_count = count_result.scalar()
                         table_info["row_count"] = row_count
                         exploration["total_rows"] += row_count
 
                     # Add sample data
                     sample_result = conn.execute(select(table).limit(3))
-                    sample_rows = [
-                        dict(row._mapping) for row in sample_result.fetchall()
-                    ]
+                    sample_rows = [dict(row._mapping) for row in sample_result.fetchall()]
                     if sample_rows:
                         table_info["sample_data"] = sample_rows
 
                     # Add content preview for text columns
                     if text_columns:
                         content_preview: Dict[str, List[Any]] = {}
-                        for col_name in text_columns[
-                            :3
-                        ]:  # Limit to first 3 text columns
+                        for col_name in text_columns[:3]:  # Limit to first 3 text columns
                             col = table.c[col_name]
                             preview_result = conn.execute(
                                 select(col).distinct().where(col.isnot(None)).limit(5)
@@ -671,9 +641,7 @@ class SQLiteMemoryDatabase:
 
             # Add embedding column as TEXT (JSON storage)
             with self.get_connection() as conn:
-                conn.execute(
-                    text(f"ALTER TABLE {table_name} ADD COLUMN {embedding_column} TEXT")
-                )
+                conn.execute(text(f"ALTER TABLE {table_name} ADD COLUMN {embedding_column} TEXT"))
                 conn.commit()
 
             self._refresh_metadata()
@@ -709,9 +677,7 @@ class SQLiteMemoryDatabase:
             table_columns = [col.name for col in table.columns]
             for col in text_columns:
                 if col not in table_columns:
-                    raise ValidationError(
-                        f"Column '{col}' not found in table '{table_name}'"
-                    )
+                    raise ValidationError(f"Column '{col}' not found in table '{table_name}'")
 
             # Add embedding column if it doesn't exist
             if embedding_column not in table_columns:
@@ -757,9 +723,7 @@ class SQLiteMemoryDatabase:
                             combined_text = " ".join(text_parts)
 
                             # Generate embedding
-                            embedding = semantic_engine.generate_embedding(
-                                combined_text
-                            )
+                            embedding = semantic_engine.generate_embedding(combined_text)
                             embedding_json = json.dumps(embedding)
 
                             # Update row with embedding
@@ -782,8 +746,7 @@ class SQLiteMemoryDatabase:
                     "message": f"Generated embeddings for {processed} rows",
                     "processed": processed,
                     "model": model_name,
-                    "embedding_dimension": semantic_engine.get_embedding_dimensions()
-                    or 0,
+                    "embedding_dimension": semantic_engine.get_embedding_dimensions() or 0,
                 }
 
         except (ValidationError, SQLAlchemyError) as e:
@@ -852,8 +815,7 @@ class SQLiteMemoryDatabase:
                         text_cols = [
                             col.name
                             for col in table.columns
-                            if "TEXT" in str(col.type).upper()
-                            or "VARCHAR" in str(col.type).upper()
+                            if "TEXT" in str(col.type).upper() or "VARCHAR" in str(col.type).upper()
                         ]
                     else:
                         text_cols = text_columns
@@ -923,9 +885,7 @@ class SQLiteMemoryDatabase:
                 target_row = conn.execute(target_stmt).fetchone()
 
                 if not target_row:
-                    raise ValidationError(
-                        f"Row with id {row_id} not found in table '{table_name}'"
-                    )
+                    raise ValidationError(f"Row with id {row_id} not found in table '{table_name}'")
 
                 target_dict = dict(target_row._mapping)
 
@@ -1099,9 +1059,7 @@ class SQLiteMemoryDatabase:
                 if not hasattr(semantic_engine, "hybrid_search") or not callable(
                     getattr(semantic_engine, "hybrid_search")
                 ):
-                    raise DatabaseError(
-                        "Semantic engine hybrid_search method is not callable"
-                    )
+                    raise DatabaseError("Semantic engine hybrid_search method is not callable")
 
                 enhanced_results = semantic_engine.hybrid_search(
                     query,
@@ -1146,10 +1104,7 @@ class SQLiteMemoryDatabase:
                 total_count = 0
                 with self.get_connection() as conn:
                     total_count = (
-                        conn.execute(
-                            select(text("COUNT(*)")).select_from(table)
-                        ).scalar()
-                        or 0
+                        conn.execute(select(text("COUNT(*)")).select_from(table)).scalar() or 0
                     )
 
                 return {
@@ -1165,8 +1120,7 @@ class SQLiteMemoryDatabase:
             with self.get_connection() as conn:
                 # Count total rows
                 total_count = (
-                    conn.execute(select(text("COUNT(*)")).select_from(table)).scalar()
-                    or 0
+                    conn.execute(select(text("COUNT(*)")).select_from(table)).scalar() or 0
                 )
 
                 # Count rows with embeddings
@@ -1207,9 +1161,7 @@ class SQLiteMemoryDatabase:
                     except json.JSONDecodeError:
                         pass
 
-                coverage_percent = (
-                    (embedded_count / total_count * 100) if total_count > 0 else 0.0
-                )
+                coverage_percent = (embedded_count / total_count * 100) if total_count > 0 else 0.0
 
                 return {
                     "success": True,

{mcp_sqlite_memory_bank-1.6.0 → mcp_sqlite_memory_bank-1.6.2}/src/mcp_sqlite_memory_bank/prompts.py

@@ -37,7 +37,9 @@ class MemoryBankPrompts:
                 # Analyze specific table
                 result = cast(Dict[str, Any], db.read_rows(table_name, {}))
                 if not result.get("success"):
-                    return f"Error: Could not access table '{table_name}'. Please check if it exists."
+                    return (
+                        f"Error: Could not access table '{table_name}'. Please check if it exists."
+                    )
 
                 rows = result.get("rows", [])
                 prompt = f"""Please analyze the content in the '{table_name}' table from the memory bank.
@@ -91,18 +93,16 @@ Focus on high-level strategic insights about the memory bank's utility and organ
             return prompt
 
         @self.mcp.prompt("search-and-summarize")
-        async def search_and_summarize(
-            query: str, max_results: Optional[int] = 10
-        ) -> str:
+        async def search_and_summarize(query: str, max_results: Optional[int] = 10) -> str:
             """Search memory content and create a summary prompt."""
             db = get_database(self.db_path)
 
             # Perform search
-            result = cast(
-                Dict[str, Any], db.search_content(query, None, max_results or 10)
-            )
+            result = cast(Dict[str, Any], db.search_content(query, None, max_results or 10))
             if not result.get("success"):
-                return f"Error: Could not search for '{query}'. {result.get('error', 'Unknown error')}"
+                return (
+                    f"Error: Could not search for '{query}'. {result.get('error', 'Unknown error')}"
+                )
 
             search_results = result.get("results", [])
             if not search_results:
@@ -111,15 +111,11 @@ Focus on high-level strategic insights about the memory bank's utility and organ
             # Format results for prompt
             formatted_results = []
             for i, result in enumerate(search_results[: max_results or 10], 1):
-                formatted_results.append(
-                    f"{i}. Table: {result.get('table', 'unknown')}"
-                )
+                formatted_results.append(f"{i}. Table: {result.get('table', 'unknown')}")
                 formatted_results.append(
                     f"   Content: {result.get('content', 'No content')[:200]}..."
                 )
-                formatted_results.append(
-                    f"   Relevance: {result.get('relevance', 'N/A')}"
-                )
+                formatted_results.append(f"   Relevance: {result.get('relevance', 'N/A')}")
                 formatted_results.append("")
 
             prompt = f"""Based on the search query "{query}", here are the most relevant results from the memory bank:
@@ -189,12 +185,8 @@ The table should include fields like: decision_name, chosen_approach, rationale,
                     f"   Rationale: {decision.get('rationale', 'Not provided')}"
                 )
                 if decision.get("alternatives"):
-                    formatted_decisions.append(
-                        f"   Alternatives: {decision.get('alternatives')}"
-                    )
-                formatted_decisions.append(
-                    f"   Date: {decision.get('timestamp', 'Unknown')}"
-                )
+                    formatted_decisions.append(f"   Alternatives: {decision.get('alternatives')}")
+                formatted_decisions.append(f"   Date: {decision.get('timestamp', 'Unknown')}")
                 formatted_decisions.append("")
 
             prompt = f"""Please analyze these technical decisions from the memory bank:

{mcp_sqlite_memory_bank-1.6.0 → mcp_sqlite_memory_bank-1.6.2}/src/mcp_sqlite_memory_bank/resources.py

@@ -36,9 +36,7 @@ class MemoryBankResources:
             result = cast(Dict[str, Any], db.list_tables())
 
             if not result.get("success"):
-                return json.dumps(
-                    {"error": "Failed to fetch tables", "details": result}
-                )
+                return json.dumps({"error": "Failed to fetch tables", "details": result})
 
             resource_content = {
                 "resource_type": "table_list",
@@ -110,9 +108,7 @@ class MemoryBankResources:
             )  # Search all tables, limit to 50 results
 
             if not result.get("success"):
-                return json.dumps(
-                    {"error": f"Failed to search for '{query}'", "details": result}
-                )
+                return json.dumps({"error": f"Failed to search for '{query}'", "details": result})
 
             search_results = result.get("results", [])
             resource_content = {
@@ -167,11 +163,7 @@ class MemoryBankResources:
                 max_rows = 0
                 for table_name, stats in table_stats.items():
                     row_count_obj = stats.get("row_count", 0)
-                    row_count = (
-                        int(row_count_obj)
-                        if isinstance(row_count_obj, (int, str))
-                        else 0
-                    )
+                    row_count = int(row_count_obj) if isinstance(row_count_obj, (int, str)) else 0
                     if row_count > max_rows:
                         max_rows = row_count
                         largest_table = table_name
@@ -198,9 +190,7 @@ class MemoryBankResources:
             # Get tables with timestamp columns for activity tracking
             tables_result = cast(Dict[str, Any], db.list_tables())
             if not tables_result.get("success"):
-                return json.dumps(
-                    {"error": "Failed to get tables", "details": tables_result}
-                )
+                return json.dumps({"error": "Failed to get tables", "details": tables_result})
 
             recent_activity = []
             tables = tables_result.get("tables", [])
@@ -214,16 +204,12 @@ class MemoryBankResources:
 
                     columns = schema_result.get("columns", [])
                     timestamp_cols = [
-                        col
-                        for col in columns
-                        if "timestamp" in col.get("name", "").lower()
+                        col for col in columns if "timestamp" in col.get("name", "").lower()
                     ]
 
                     if timestamp_cols:
                         # Get recent entries (last 10)
-                        recent_result = cast(
-                            Dict[str, Any], db.read_rows(table_name, None, 10)
-                        )
+                        recent_result = cast(Dict[str, Any], db.read_rows(table_name, None, 10))
                         if recent_result.get("success"):
                             rows = recent_result.get("rows", [])
                             for row in rows:
@@ -240,7 +226,7 @@ class MemoryBankResources:
                                 }
                                 recent_activity.append(activity_entry)
 
-                except Exception as e:
+                except Exception:
                     continue
 
             # Sort by timestamp (most recent first)
@@ -308,9 +294,7 @@ class MemoryBankResources:
                                 embedding_stats.get("success")
                                 and embedding_stats.get("coverage_percent", 0) == 0
                             ):
-                                schema_result = cast(
-                                    Dict[str, Any], db.describe_table(table_name)
-                                )
+                                schema_result = cast(Dict[str, Any], db.describe_table(table_name))
                                 if schema_result.get("success"):
                                     text_cols = [
                                         col
@@ -354,7 +338,7 @@ class MemoryBankResources:
                                     }
                                 )
 
-                    except Exception as e:
+                    except Exception:
                         continue
 
                 # Prioritize suggestions
@@ -407,9 +391,7 @@ class MemoryBankResources:
             try:
                 tables_result = cast(Dict[str, Any], db.list_tables())
                 if not tables_result.get("success"):
-                    return json.dumps(
-                        {"error": "Failed to get insights", "details": tables_result}
-                    )
+                    return json.dumps({"error": "Failed to get insights", "details": tables_result})
 
                 tables = tables_result.get("tables", [])
                 total_rows = 0
@@ -433,13 +415,9 @@ class MemoryBankResources:
                                         total_content_length += len(value)
 
                             avg_content_length = (
-                                total_content_length / sample_size
-                                if sample_size > 0
-                                else 0
+                                total_content_length / sample_size if sample_size > 0 else 0
                             )
-                            quality_score = min(
-                                10, avg_content_length / 50
-                            )  # Normalize to 0-10
+                            quality_score = min(10, avg_content_length / 50)  # Normalize to 0-10
                             content_quality_scores.append(quality_score)
 
                             insights["usage_patterns"][table_name] = {
@@ -449,11 +427,7 @@ class MemoryBankResources:
                                 "category": (
                                     "high_value"
                                     if quality_score > 7
-                                    else (
-                                        "medium_value"
-                                        if quality_score > 3
-                                        else "low_value"
-                                    )
+                                    else ("medium_value" if quality_score > 3 else "low_value")
                                 ),
                             }
 

{mcp_sqlite_memory_bank-1.6.0 → mcp_sqlite_memory_bank-1.6.2}/src/mcp_sqlite_memory_bank/semantic.py

@@ -69,9 +69,7 @@ class SemanticSearchEngine:
                 self._model = SentenceTransformer(self.model_name)
                 logging.info(f"Loaded semantic search model: {self.model_name}")
             except Exception as e:
-                raise DatabaseError(
-                    f"Failed to load semantic search model {self.model_name}: {e}"
-                )
+                raise DatabaseError(f"Failed to load semantic search model {self.model_name}: {e}")
         return self._model
 
     def get_embedding_dimensions(self) -> Optional[int]:
@@ -136,9 +134,7 @@ class SemanticSearchEngine:
         except Exception as e:
             raise DatabaseError(f"Failed to generate batch embeddings: {e}")
 
-    def calculate_similarity(
-        self, embedding1: List[float], embedding2: List[float]
-    ) -> float:
+    def calculate_similarity(self, embedding1: List[float], embedding2: List[float]) -> float:
         """
         Calculate cosine similarity between two embeddings.
 
@@ -226,9 +222,7 @@ class SemanticSearchEngine:
                 results.sort(key=lambda x: x[1], reverse=True)
                 return results[:top_k]
             except Exception as e:
-                logging.warning(
-                    f"Torch similarity search failed, using numpy fallback: {e}"
-                )
+                logging.warning(f"Torch similarity search failed, using numpy fallback: {e}")
 
         # Fallback to numpy implementation
         results = []
@@ -317,11 +311,7 @@ class SemanticSearchEngine:
                 if content_columns:
                     matched_content = []
                     for col in content_columns:
-                        if (
-                            col in row
-                            and row[col]
-                            and query.lower() in str(row[col]).lower()
-                        ):
+                        if col in row and row[col] and query.lower() in str(row[col]).lower():
                             matched_content.append(f"{col}: {row[col]}")
                     if matched_content:
                         row["matched_content"] = matched_content
@@ -367,14 +357,9 @@ class SemanticSearchEngine:
             semantic_weight /= total_weight
             text_weight /= total_weight
 
-        # Get semantic search results
-        semantic_results = self.semantic_search(
-            query,
-            content_data,
-            embedding_column,
-            similarity_threshold=0.3,
-            top_k=top_k * 2,  # Get more for reranking
-        )
+        # Use the provided content_data as semantic results (already filtered by database)
+        # The content_data passed here should already be the semantic search results
+        semantic_results = content_data.copy() if content_data else []
 
         # Add text matching scores
         query_lower = query.lower()
@@ -387,15 +372,11 @@ class SemanticSearchEngine:
                         content = str(result[col]).lower()
                         if query_lower in content:
                             # Simple frequency-based text scoring
-                            text_score += content.count(query_lower) / len(
-                                content.split()
-                            )
+                            text_score += content.count(query_lower) / len(content.split())
 
             # Combine scores
             semantic_score = result.get("similarity_score", 0.0)
-            combined_score = (semantic_score * semantic_weight) + (
-                text_score * text_weight
-            )
+            combined_score = (semantic_score * semantic_weight) + (text_score * text_weight)
             result["combined_score"] = round(combined_score, 3)
             result["text_score"] = round(text_score, 3)
 
@@ -421,9 +402,7 @@ def get_semantic_engine(model_name: str = "all-MiniLM-L6-v2") -> SemanticSearchE
     try:
         if _semantic_engine is None or _semantic_engine.model_name != model_name:
             if not SENTENCE_TRANSFORMERS_AVAILABLE:
-                raise ValueError(
-                    "Sentence transformers not available for semantic search"
-                )
+                raise ValueError("Sentence transformers not available for semantic search")
             _semantic_engine = SemanticSearchEngine(model_name)
 
         # Verify the engine is properly initialized