done

app.py

@@ -29,6 +29,7 @@ app.add_middleware(
 # Include API routes
 app.include_router(router)
 
+
 # Global exception handler
 @app.exception_handler(Exception)
 async def global_exception_handler(request, exc):
@@ -39,16 +40,16 @@ async def global_exception_handler(request, exc):
             status_code=500,
             content={
                 "detail": f"Internal server error: {str(exc)}",
-                "type": type(exc).__name__
-            }
+                "type": type(exc).__name__,
+            },
         )
     else:
         # In production, return generic error message
         return JSONResponse(
-            status_code=500,
-            content={"detail": "Internal server error"}
+            status_code=500, content={"detail": "Internal server error"}
         )
 
+
 # Root endpoint
 @app.get("/", summary="Root endpoint")
 async def root():
@@ -60,10 +61,11 @@ async def root():
         "endpoints": {
             "extract_narrators": "/api/v1/extract-narrators",
             "analyze_narrator": "/api/v1/analyze-narrator",
-            "health": "/api/v1/health"
-        }
+            "health": "/api/v1/health",
+        },
     }
 
+
 # Startup event
 @app.on_event("startup")
 async def startup_event():
@@ -71,23 +73,21 @@ async def startup_event():
     # Validate required environment variables
     if not settings.GOOGLE_API_KEY:
         raise ValueError("GOOGLE_API_KEY environment variable is required")
-    
+
     print(f"Starting {settings.API_TITLE} v{settings.API_VERSION}")
     print(f"Environment: {settings.ENVIRONMENT}")
     print(f"Debug mode: {settings.DEBUG}")
 
+
 # Shutdown event
 @app.on_event("shutdown")
 async def shutdown_event():
     """Shutdown event handler."""
     print("Shutting down SanadCheck API")
 
+
 if __name__ == "__main__":
     # Run the application
     uvicorn.run(
-        "app:app",
-        host="0.0.0.0",
-        port=8000,
-        reload=settings.DEBUG,
-        log_level="info"
+        "app:app", host="0.0.0.0", port=8000, reload=settings.DEBUG, log_level="info"
     )

config.py

@@ -2,29 +2,28 @@ import os
 from typing import Optional
 
 
-
 class Settings:
     """Application settings."""
-    
+
     # API Settings
     API_TITLE: str = "SanadCheck API"
     API_DESCRIPTION: str = "API for Hadith narrator analysis and validation"
     API_VERSION: str = "1.0.0"
-    
+
     # Environment
     ENVIRONMENT: str = os.getenv("ENVIRONMENT", "development")
     DEBUG: bool = os.getenv("DEBUG", "True").lower() == "true"
-    
+
     # Google AI
     GOOGLE_API_KEY: Optional[str] = os.getenv("GOOGLE_API_KEY")
-    
+
     # Rate Limiting
     RATE_LIMIT_REQUESTS: int = int(os.getenv("RATE_LIMIT_REQUESTS", "100"))
     RATE_LIMIT_WINDOW: int = int(os.getenv("RATE_LIMIT_WINDOW", "3600"))  # 1 hour
-    
+
     # CORS
     ALLOWED_ORIGINS: list = os.getenv("ALLOWED_ORIGINS", "*").split(",")
-    
+
     class Config:
         env_file = ".env"
 

constants.py

@@ -65,17 +65,17 @@ Provide a clear, humble, and well-justified analysis combining Shamela data and
 
 # Synthesis prompt constant (use PromptTemplate with this constant)
 SYNTHESIS_PROMPT = (
-"As a hadith expert, analyze this complete chain of narrators and provide an overall assessment:\n\n"
-"INDIVIDUAL NARRATOR ANALYSES:\n{narrator_summaries}\n\n"
-"Provide an overall chain assessment considering:\n"
-"1. Weakest link principle - the chain is only as strong as its weakest narrator\n"
-"2. Cumulative reliability - multiple weak narrators compound the weakness\n"
-"3. Historical context and scholarly methodology\n"
-"4. Practical recommendations for hadith scholars\n\n"
-"Response format:\n"
-"- Overall Chain Grade: [Sahih/Hasan/Da'if/Mawdu']\n"
-"- Confidence Level: [High/Medium/Low]\n"
-"- Critical Issues: [Main concerns]\n"
+    "As a hadith expert, analyze this complete chain of narrators and provide an overall assessment:\n\n"
+    "INDIVIDUAL NARRATOR ANALYSES:\n{narrator_summaries}\n\n"
+    "Provide an overall chain assessment considering:\n"
+    "1. Weakest link principle - the chain is only as strong as its weakest narrator\n"
+    "2. Cumulative reliability - multiple weak narrators compound the weakness\n"
+    "3. Historical context and scholarly methodology\n"
+    "4. Practical recommendations for hadith scholars\n\n"
+    "Response format:\n"
+    "- Overall Chain Grade: [Sahih/Hasan/Da'if/Mawdu']\n"
+    "- Confidence Level: [High/Medium/Low]\n"
+    "- Critical Issues: [Main concerns]\n"
     "- Recommendation: [Accept/Use with caution/Reject]\n"
     "- Reasoning: [Detailed explanation]\n"
-    )
+)

routes.py

@@ -3,7 +3,7 @@ from fastapi.responses import JSONResponse
 from typing import List, Dict, Any
 
 from models import (
-    HadithTextRequest, 
+    HadithTextRequest,
     NarratorExtractionResponse,
     NarratorAnalysisRequest,
     NarratorAnalysisResponse,
@@ -13,7 +13,7 @@ from models import (
     ChainAnalysisMetadata,
     ExtractionResult,
     ChainAnalysisResult,
-    ExtractAndAnalyzeMetadata
+    ExtractAndAnalyzeMetadata,
 )
 from services import get_llm_service
 
@@ -24,43 +24,43 @@ router = APIRouter(prefix="/api/v1", tags=["hadith-analysis"])
     "/extract-narrators",
     response_model=NarratorExtractionResponse,
     summary="Extract narrators from hadith text",
-    description="Analyzes Arabic hadith text and extracts the chain of narrators (sanad)"
+    description="Analyzes Arabic hadith text and extracts the chain of narrators (sanad)",
 )
 async def extract_narrators(request: HadithTextRequest) -> NarratorExtractionResponse:
     """
     Extract narrators from hadith text.
-    
+
     This endpoint takes a complete hadith text in Arabic and uses AI to identify
     and extract the chain of narrators (sanad), returning individual narrator names
     that can be used for database searches.
-    
+
     Args:
         request: Contains the hadith text to analyze
-        
+
     Returns:
         NarratorExtractionResponse with extracted narrator names and chain
-        
+
     Raises:
         HTTPException: If the analysis fails
     """
     try:
         llm_service = get_llm_service()
         result = await llm_service.extract_narrators(request.hadith_text)
-        
+
         if not result.success:
             raise HTTPException(
                 status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail=f"Failed to extract narrators: {result.message}"
+                detail=f"Failed to extract narrators: {result.message}",
             )
-        
+
         return result
-        
+
     except HTTPException:
         raise
     except Exception as e:
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Internal server error during narrator extraction: {str(e)}"
+            detail=f"Internal server error during narrator extraction: {str(e)}",
         )
 
 
@@ -68,43 +68,45 @@ async def extract_narrators(request: HadithTextRequest) -> NarratorExtractionRes
     "/analyze-narrator",
     response_model=NarratorAnalysisResponse,
     summary="Analyze narrator reliability",
-    description="Takes a narrator name and generates an AI-powered reliability assessment based on the model's knowledge"
+    description="Takes a narrator name and generates an AI-powered reliability assessment based on the model's knowledge",
 )
-async def analyze_narrator(request: NarratorAnalysisRequest) -> NarratorAnalysisResponse:
+async def analyze_narrator(
+    request: NarratorAnalysisRequest,
+) -> NarratorAnalysisResponse:
     """
     Analyze narrator reliability based on the model's internal knowledge.
-    
-    This endpoint takes a narrator's name and uses AI to provide a comprehensive 
-    reliability assessment based on its knowledge of Islamic hadith criticism 
+
+    This endpoint takes a narrator's name and uses AI to provide a comprehensive
+    reliability assessment based on its knowledge of Islamic hadith criticism
     methodologies and historical narrator evaluations.
-    
+
     Args:
         request: Contains the narrator name to analyze
-        
+
     Returns:
         NarratorAnalysisResponse with reliability grade, biographical info, and detailed analysis
-        
+
     Raises:
         HTTPException: If the analysis fails
     """
     try:
         llm_service = get_llm_service()
         result = await llm_service.analyze_narrator(request.narrator_name)
-        
+
         if not result.success:
             raise HTTPException(
                 status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-                detail=f"Failed to analyze narrator: {result.message}"
+                detail=f"Failed to analyze narrator: {result.message}",
             )
-        
+
         return result
-        
+
     except HTTPException:
         raise
     except Exception as e:
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Internal server error during narrator analysis: {str(e)}"
+            detail=f"Internal server error during narrator analysis: {str(e)}",
         )
 
 
@@ -112,22 +114,24 @@ async def analyze_narrator(request: NarratorAnalysisRequest) -> NarratorAnalysis
     "/analyze-narrator-chain",
     response_model=NarratorChainAnalysisResponse,
     summary="Analyze narrator chain",
-    description="Analyzes a complete chain of narrators using enhanced Shamela data + LLM agent"
+    description="Analyzes a complete chain of narrators using enhanced Shamela data + LLM agent",
 )
-async def analyze_narrator_chain(narrator_names: List[str]) -> NarratorChainAnalysisResponse:
+async def analyze_narrator_chain(
+    narrator_names: List[str],
+) -> NarratorChainAnalysisResponse:
     """
     Analyze a complete chain of narrators with enhanced data sources.
-    
+
     This endpoint takes a list of narrator names and uses the enhanced agent approach
     to analyze each narrator using both Shamela.ws data and LLM knowledge, then
     provides a synthesized assessment of the complete chain.
-    
+
     Args:
         narrator_names: List of narrator names in the chain
-        
+
     Returns:
         Dictionary containing individual analyses and chain synthesis
-        
+
     Raises:
         HTTPException: If the analysis fails
     """
@@ -135,17 +139,17 @@ async def analyze_narrator_chain(narrator_names: List[str]) -> NarratorChainAnal
         if not narrator_names:
             raise HTTPException(
                 status_code=status.HTTP_400_BAD_REQUEST,
-                detail="narrator_names list cannot be empty"
+                detail="narrator_names list cannot be empty",
             )
-        
+
         llm_service = get_llm_service()
-        
+
         # Analyze individual narrators
         chain_results = await llm_service.analyze_narrator_chain(narrator_names)
-        
+
         # Synthesize chain analysis
         synthesis = await llm_service.synthesize_chain_analysis(chain_results)
-        
+
         return NarratorChainAnalysisResponse(
             chain=narrator_names,
             individual_analyses={
@@ -159,7 +163,7 @@ async def analyze_narrator_chain(narrator_names: List[str]) -> NarratorChainAnal
                     biographical_info=result.biographical_info,
                     recommendation=result.recommendation,
                     success=result.success,
-                    message=result.message
+                    message=result.message,
                 )
                 for name, result in chain_results.items()
             },
@@ -167,16 +171,16 @@ async def analyze_narrator_chain(narrator_names: List[str]) -> NarratorChainAnal
             metadata=ChainAnalysisMetadata(
                 total_narrators=len(narrator_names),
                 successful_analyses=sum(1 for r in chain_results.values() if r.success),
-                analysis_method="Enhanced agent with Shamela.ws + LLM"
-            )
+                analysis_method="Enhanced agent with Shamela.ws + LLM",
+            ),
         )
-        
+
     except HTTPException:
         raise
     except Exception as e:
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Internal server error during chain analysis: {str(e)}"
+            detail=f"Internal server error during chain analysis: {str(e)}",
         )
 
 
@@ -184,58 +188,62 @@ async def analyze_narrator_chain(narrator_names: List[str]) -> NarratorChainAnal
     "/extract-and-analyze",
     response_model=ExtractAndAnalyzeResponse,
     summary="Extract narrators and analyze chain",
-    description="Complete workflow: extract narrators from hadith text and analyze the complete chain"
+    description="Complete workflow: extract narrators from hadith text and analyze the complete chain",
 )
-async def extract_and_analyze_hadith(request: HadithTextRequest) -> ExtractAndAnalyzeResponse:
+async def extract_and_analyze_hadith(
+    request: HadithTextRequest,
+) -> ExtractAndAnalyzeResponse:
     """
     Complete hadith analysis workflow: extraction + chain analysis.
-    
+
     This endpoint combines narrator extraction and chain analysis in one call,
     providing a complete assessment of a hadith's chain of narration.
-    
+
     Args:
         request: Contains the hadith text to analyze
-        
+
     Returns:
         Complete analysis including extraction results and chain assessment
-        
+
     Raises:
         HTTPException: If the analysis fails
     """
     try:
         llm_service = get_llm_service()
-        
+
         # Step 1: Extract narrators
         extraction_result = await llm_service.extract_narrators(request.hadith_text)
-        
+
         if not extraction_result.success or not extraction_result.narrators:
             return ExtractAndAnalyzeResponse(
                 extraction=ExtractionResult(
                     narrators=extraction_result.narrators,
                     sanad_chain=extraction_result.sanad_chain,
                     success=extraction_result.success,
-                    message=extraction_result.message
+                    message=extraction_result.message,
                 ),
                 chain_analysis=None,
                 metadata=ExtractAndAnalyzeMetadata(
                     hadith_text_length=len(request.hadith_text),
                     extracted_narrators_count=len(extraction_result.narrators),
                     successful_analyses=0,
-                    analysis_method="Enhanced agent with Shamela.ws + LLM"
+                    analysis_method="Enhanced agent with Shamela.ws + LLM",
                 ),
-                error="Failed to extract narrators or no narrators found"
+                error="Failed to extract narrators or no narrators found",
             )
-        
+
         # Step 2: Analyze narrator chain
-        chain_results = await llm_service.analyze_narrator_chain(extraction_result.narrators)
+        chain_results = await llm_service.analyze_narrator_chain(
+            extraction_result.narrators
+        )
         synthesis = await llm_service.synthesize_chain_analysis(chain_results)
-        
+
         return ExtractAndAnalyzeResponse(
             extraction=ExtractionResult(
                 narrators=extraction_result.narrators,
                 sanad_chain=extraction_result.sanad_chain,
                 success=extraction_result.success,
-                message=extraction_result.message
+                message=extraction_result.message,
             ),
             chain_analysis=ChainAnalysisResult(
                 individual_analyses={
@@ -249,43 +257,43 @@ async def extract_and_analyze_hadith(request: HadithTextRequest) -> ExtractAndAn
                         biographical_info=result.biographical_info,
                         recommendation=result.recommendation,
                         success=result.success,
-                        message=result.message
+                        message=result.message,
                     )
                     for name, result in chain_results.items()
                 },
-                synthesis=synthesis
+                synthesis=synthesis,
             ),
             metadata=ExtractAndAnalyzeMetadata(
                 hadith_text_length=len(request.hadith_text),
                 extracted_narrators_count=len(extraction_result.narrators),
                 successful_analyses=sum(1 for r in chain_results.values() if r.success),
-                analysis_method="Enhanced agent with Shamela.ws + LLM"
-            )
+                analysis_method="Enhanced agent with Shamela.ws + LLM",
+            ),
         )
-        
+
     except HTTPException:
         raise
     except Exception as e:
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Internal server error during complete analysis: {str(e)}"
+            detail=f"Internal server error during complete analysis: {str(e)}",
         )
 
 
 @router.get(
     "/health",
     summary="Health check",
-    description="Check if the API is running and healthy"
+    description="Check if the API is running and healthy",
 )
 async def health_check():
     """Health check endpoint."""
     return {
-        "status": "healthy", 
+        "status": "healthy",
         "message": "SanadCheck API is running",
         "features": [
             "Enhanced narrator analysis with Shamela.ws integration",
             "Narrator chain analysis",
             "Complete hadith workflow analysis",
-            "AI-powered narrator extraction"
-        ]
+            "AI-powered narrator extraction",
+        ],
     }

services.py

@@ -1,6 +1,6 @@
 from functools import lru_cache
 import json
-from typing import Dict, Any, Optional, cast
+from typing import Dict, Any, cast
 
 from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain.output_parsers import PydanticOutputParser
@@ -17,14 +17,13 @@ import asyncio
 load_dotenv()
 
 
-
 class LLMService:
     """Service class for LLM operations."""
-    
+
     def __init__(self):
         self.model_name = "gemini-1.5-flash-latest"
         self._llm = None
-    
+
     @property
     def llm(self) -> ChatGoogleGenerativeAI:
         """Lazy initialization of LLM."""
@@ -35,41 +34,46 @@ class LLMService:
                 max_output_tokens=2048,
             )
         return self._llm
-    
+
     async def extract_narrators(self, hadith_text: str) -> NarratorExtractionResponse:
         """Extract narrators from hadith text."""
         try:
             # Create parser for structured output
             parser = PydanticOutputParser(pydantic_object=NarratorExtractionResponse)
-            
+
             # Create prompt template
             prompt_template = PromptTemplate(
                 template=EXTRACT_PROMPT,
                 input_variables=["hadith_text"],
-                partial_variables={"format_instructions": parser.get_format_instructions()},
+                partial_variables={
+                    "format_instructions": parser.get_format_instructions()
+                },
             )
-            
+
             # Create chain
             chain = prompt_template | self.llm | parser
-            
+
             # Invoke chain
             result = await chain.ainvoke({"hadith_text": hadith_text})
-            
+
             return result
-            
+
         except Exception as e:
             return NarratorExtractionResponse(
                 narrators=[],
                 sanad_chain="",
                 success=False,
-                message=f"Error extracting narrators: {str(e)}"
+                message=f"Error extracting narrators: {str(e)}",
             )
+
     async def analyze_narrator(self, narrator_name: str) -> NarratorAnalysisResponse:
         """Enhanced narrator analyzer agent that uses Shamela scraper and LLM reasoning."""
         try:
             # Step 1: Scrape data from Shamela
             try:
-                shamela_data = await ShamelaNarratorExtractor.extract_narrator_by_name(narrator_name)
+                shamela_data = await ShamelaNarratorExtractor.extract_narrator_by_name(
+                    narrator_name
+                )
             except Exception as shamela_error:
                 shamela_data = {"error": f"Extraction failed: {str(shamela_error)}"}
 
@@ -77,15 +81,19 @@ class LLMService:
             try:
                 shamela_context = self._format_shamela_data(shamela_data)
             except Exception as format_error:
-                shamela_context = f"❌ Failed to format Shamela data: {str(format_error)}"
-            
+                shamela_context = (
+                    f"❌ Failed to format Shamela data: {str(format_error)}"
+                )
+
             # Step 3: Create enhanced prompt with Shamela data
             try:
                 parser = PydanticOutputParser(pydantic_object=NarratorAnalysisResponse)
                 prompt_template = PromptTemplate(
                     template=ANALYZE_PROMPT,
                     input_variables=["narrator_name", "shamela_context"],
-                    partial_variables={"format_instructions": parser.get_format_instructions()},
+                    partial_variables={
+                        "format_instructions": parser.get_format_instructions()
+                    },
                 )
             except Exception as prompt_error:
                 raise prompt_error
@@ -93,26 +101,29 @@ class LLMService:
             # Step 4: Invoke the enhanced analysis
             try:
                 chain = prompt_template | self.llm | parser
-                result = await chain.ainvoke({
-                    "narrator_name": narrator_name,
-                    "shamela_context": shamela_context
-                })
+                result = await chain.ainvoke(
+                    {"narrator_name": narrator_name, "shamela_context": shamela_context}
+                )
             except Exception as chain_error:
                 raise chain_error
 
             # Step 5: Enhance the response with metadata
             try:
                 total_scholars = 0
-                if shamela_data and isinstance(shamela_data, dict) and not shamela_data.get("error"):
-                    metadata = shamela_data.get('extraction_metadata', {})
+                if (
+                    shamela_data
+                    and isinstance(shamela_data, dict)
+                    and not shamela_data.get("error")
+                ):
+                    metadata = shamela_data.get("extraction_metadata", {})
                     if isinstance(metadata, dict):
-                        total_scholars = metadata.get('total_scholars', 0)
+                        total_scholars = metadata.get("total_scholars", 0)
                 result.message = f"Analysis completed using Shamela data ({total_scholars} scholars) + LLM knowledge"
                 result.success = True
                 return result
             except Exception as metadata_error:
                 return result
-            
+
         except Exception as e:
             return NarratorAnalysisResponse(
                 narrator_name=narrator_name,
@@ -124,10 +135,12 @@ class LLMService:
                 biographical_info="Unable to retrieve information due to error",
                 recommendation="Cannot provide recommendation due to analysis failure",
                 success=False,
-                message=f"Error analyzing narrator: {str(e)}"
+                message=f"Error analyzing narrator: {str(e)}",
             )
-        
-    async def analyze_narrator_chain(self, narrator_names: list[str]) -> Dict[str, NarratorAnalysisResponse]:
+
+    async def analyze_narrator_chain(
+        self, narrator_names: list[str]
+    ) -> Dict[str, NarratorAnalysisResponse]:
         """Analyze a complete chain of narrators concurrently."""
 
         results: Dict[str, NarratorAnalysisResponse] = {}
@@ -138,7 +151,9 @@ class LLMService:
         print(f"Analyzing chain of {len(narrator_names)} narrators concurrently...")
 
         # Fire off all analysis tasks at once
-        tasks = [asyncio.create_task(self.analyze_narrator(name)) for name in narrator_names]
+        tasks = [
+            asyncio.create_task(self.analyze_narrator(name)) for name in narrator_names
+        ]
 
         # Wait for all to complete, capturing exceptions per-task
         completed = await asyncio.gather(*tasks, return_exceptions=True)
@@ -156,99 +171,126 @@ class LLMService:
                     biographical_info="Error during analysis",
                     recommendation="Cannot recommend due to error",
                     success=False,
-                    message=f"Error in chain analysis: {str(outcome)}"
+                    message=f"Error in chain analysis: {str(outcome)}",
                 )
             else:
                 results[name] = cast(NarratorAnalysisResponse, outcome)
 
         return results
-    async def synthesize_chain_analysis(self, chain_results: Dict[str, NarratorAnalysisResponse]) -> Dict[str, Any]:
+
+    async def synthesize_chain_analysis(
+        self, chain_results: Dict[str, NarratorAnalysisResponse]
+    ) -> Dict[str, Any]:
         """Synthesize individual narrator analyses into an overall chain assessment."""
         try:
             # Prepare data for synthesis
             narrator_summaries = []
             for name, analysis in chain_results.items():
-                narrator_summaries.append({
-                    "name": name,
-                    "grade": analysis.reliability_grade,
-                    "confidence": analysis.confidence_level,
-                    "reasoning": analysis.reasoning[:200] + "..." if len(analysis.reasoning) > 200 else analysis.reasoning,
-                    "issues": analysis.known_issues
-                })
+                narrator_summaries.append(
+                    {
+                        "name": name,
+                        "grade": analysis.reliability_grade,
+                        "confidence": analysis.confidence_level,
+                        "reasoning": (
+                            analysis.reasoning[:200] + "..."
+                            if len(analysis.reasoning) > 200
+                            else analysis.reasoning
+                        ),
+                        "issues": analysis.known_issues,
+                    }
+                )
             # Create PromptTemplate and invoke LLM
             prompt_template = PromptTemplate(
-            template=SYNTHESIS_PROMPT,
-            input_variables=["narrator_summaries"],
+                template=SYNTHESIS_PROMPT,
+                input_variables=["narrator_summaries"],
             )
 
-            summaries_json = json.dumps(narrator_summaries, ensure_ascii=False, indent=2)
+            summaries_json = json.dumps(
+                narrator_summaries, ensure_ascii=False, indent=2
+            )
             chain = prompt_template | self.llm
-            synthesis_result = await chain.ainvoke({"narrator_summaries": summaries_json})
+            synthesis_result = await chain.ainvoke(
+                {"narrator_summaries": summaries_json}
+            )
 
             # Normalize synthesis text
             synthesis_text = getattr(synthesis_result, "content", synthesis_result)
-            
+
             return {
-            "overall_assessment": synthesis_text,
-            "individual_results": chain_results,
-            "chain_length": len(chain_results),
-            "success": True
+                "overall_assessment": synthesis_text,
+                "individual_results": chain_results,
+                "chain_length": len(chain_results),
+                "success": True,
             }
-            
+
             return {
                 "overall_assessment": synthesis_result.content,
                 "individual_results": chain_results,
                 "chain_length": len(chain_results),
-                "success": True
+                "success": True,
             }
-            
+
         except Exception as e:
             return {
                 "overall_assessment": f"Synthesis failed: {str(e)}",
                 "individual_results": chain_results,
                 "chain_length": len(chain_results),
-                "success": False
+                "success": False,
             }
 
     def _format_shamela_data(self, narrator_info: Dict[str, Any]) -> str:
         """Format Shamela data for LLM consumption."""
         if not narrator_info or narrator_info.get("error"):
             return "❌ No data found on Shamela.ws or extraction failed"
-        
+
         context_parts = []
-        
+
         # Basic info
         if narrator_info.get("narrator_name"):
-            context_parts.append(f"**Narrator Name (Shamela):** {narrator_info['narrator_name']}")
+            context_parts.append(
+                f"**Narrator Name (Shamela):** {narrator_info['narrator_name']}"
+            )
 
         # Biographical information
         if narrator_info.get("biographical_info"):
             context_parts.append("**📋 Biographical Information:**")
-            for key, value in narrator_info['biographical_info'].items():
+            for key, value in narrator_info["biographical_info"].items():
                 context_parts.append(f"  • {key}: {value}")
         else:
             context_parts.append("**📋 Biographical Information:** None found")
-        
+
         # Scholarly critique
         if narrator_info.get("scholarly_critique"):
-            context_parts.append(f"**📚 Scholarly Opinions ({len(narrator_info['scholarly_critique'])} scholars):**")
-            for i, scholar_critique in enumerate(narrator_info['scholarly_critique'], 1):
+            context_parts.append(
+                f"**📚 Scholarly Opinions ({len(narrator_info['scholarly_critique'])} scholars):**"
+            )
+            for i, scholar_critique in enumerate(
+                narrator_info["scholarly_critique"], 1
+            ):
                 context_parts.append(f"\n  {i}. **{scholar_critique['scholar']}:**")
-                for comment in scholar_critique['comments']:
+                for comment in scholar_critique["comments"]:
                     context_parts.append(f"     - {comment['text']}")
-                    if comment.get('highlighted'):
-                        context_parts.append(f"       (Highlighted terms: {', '.join(comment['highlighted'])})")
+                    if comment.get("highlighted"):
+                        context_parts.append(
+                            f"       (Highlighted terms: {', '.join(comment['highlighted'])})"
+                        )
         else:
             context_parts.append("**📚 Scholarly Opinions:** None found")
-        
+
         # Metadata
         metadata = narrator_info.get("extraction_metadata", {})
         context_parts.append(f"\n**📊 Data Quality:**")
-        context_parts.append(f"  • Total scholars cited: {metadata.get('total_scholars', 0)}")
+        context_parts.append(
+            f"  • Total scholars cited: {metadata.get('total_scholars', 0)}"
+        )
         context_parts.append(f"  • Total comments: {metadata.get('total_comments', 0)}")
-        context_parts.append(f"  • Biographical fields: {metadata.get('biographical_fields', 0)}")
-        context_parts.append(f"  • Has critique section: {metadata.get('has_critique_section', False)}")
-        
+        context_parts.append(
+            f"  • Biographical fields: {metadata.get('biographical_fields', 0)}"
+        )
+        context_parts.append(
+            f"  • Has critique section: {metadata.get('has_critique_section', False)}"
+        )
+
         return "\n".join(context_parts)