/notes-llm added, system.md file added

agents/langgraph.py

@@ -7,6 +7,7 @@ from agents.simple_tools import (
     generate_balance_sheet,
     generate_pnl_statement,
     generate_cash_flow_statement,
+    generate_llm_notes,
 )
 
 class FinancialAgentState(TypedDict):
@@ -44,6 +45,7 @@ workflows = {
     "pnl": make_workflow(generate_pnl_statement),
     "bs": make_workflow(generate_balance_sheet),
     "cf": make_workflow(generate_cash_flow_statement),
+    "notes-llm": make_workflow(generate_llm_notes),
 }
 
 def run_workflow(file_path: str, kind: str) -> Dict[str, Any]:

agents/rlhf_workflows.py

@@ -16,6 +16,7 @@ from agents.simple_tools import (
     generate_balance_sheet,
     generate_pnl_statement,
     generate_cash_flow_statement,
+    generate_llm_notes,
 )
 from agents.feedback_manager import FeedbackManager
 from agents.reward_model import FinancialRewardModel, RLHFTrainer
@@ -228,6 +229,7 @@ rlhf_workflows = {
     "pnl": rlhf_manager.make_rlhf_workflow(generate_pnl_statement, "pnl"),
     "bs": rlhf_manager.make_rlhf_workflow(generate_balance_sheet, "balance_sheet"),
     "cf": rlhf_manager.make_rlhf_workflow(generate_cash_flow_statement, "cash_flow"),
+    "notes-llm": rlhf_manager.make_rlhf_workflow(generate_llm_notes, "notes"),
 }
 
 def run_rlhf_workflow(file_path: str, kind: str) -> Dict[str, Any]:

agents/simple_agent.py

@@ -32,6 +32,7 @@ class FinancialStatementAgent:
         try:
             prompts = {
                 "notes": f"Generate financial notes for note numbers {note_numbers} from {file_path}",
+                "notes-llm": f"Generate financial notes using LLM for note numbers {note_numbers} from {file_path}",
                 "balance_sheet": f"Generate balance sheet from {file_path} using note numbers {note_numbers}",
                 "pnl": f"Generate P&L statement from {file_path} using note numbers {note_numbers}",
                 "cash_flow": f"Generate cash flow statement from {file_path} using note numbers {note_numbers}"

agents/simple_tools.py

@@ -278,6 +278,10 @@ def generate_cash_flow_statement(file_path: str) -> Dict[str, Any]:
         if os.getenv("OPENROUTER_API_KEY"):
             env["OPENROUTER_API_KEY"] = os.getenv("OPENROUTER_API_KEY")
         env["INPUT_FILE"] = "data/clean_financial_data_cfs.json"
+        env["CFS_JSON_INPUT"] = "data/clean_financial_data_cfs.json"
+        env["CFS_JSON_OUTPUT"] = "data/extracted_cfs_data.json"
+        env["CFS_EXTRACTED_FILE"] = "data/extracted_cfs_data.json"
+        env["CFS_OUTPUT_FILE"] = "data/cash_flow_statements.xlsx"
         cwd = os.getcwd()
         
         # Step 1: Run cash_flow_data_extractor.py
@@ -366,10 +370,109 @@ def generate_cash_flow_statement(file_path: str) -> Dict[str, Any]:
             "execution_time": execution_time
         }
 
+@tool
+def generate_llm_notes(file_path: str, note_numbers: str = "") -> Dict[str, Any]:
+    """
+    Generate notes using LLM-based approach (FlexibleFinancialNoteGenerator)
+    Args:
+        file_path: Path to trial balance Excel file
+        note_numbers: Optional comma-separated note numbers to generate
+    Returns:
+        dict with status, output_xlsx_path, and error if any
+    """
+    execution_id = str(uuid.uuid4())[:8]
+    start_time = time.time()
+
+    try:
+        # Use the complete LLM notes pipeline from existing scripts
+        env = os.environ.copy()
+        if os.getenv("OPENROUTER_API_KEY"):
+            env["OPENROUTER_API_KEY"] = os.getenv("OPENROUTER_API_KEY")
+        cwd = os.getcwd()
+
+        # Step 1: Run LLM notes data processor
+        logger.info("Step 1: Processing trial balance data")
+        result1 = subprocess.run(
+            ["python", "notes/llm_notes_data_processor.py", file_path],
+            env=env,
+            cwd=cwd,
+            capture_output=True,
+            text=True
+        )
+
+        if result1.returncode != 0:
+            return {"status": "error", "error": f"LLM notes data processing failed: {result1.stderr}"}
+
+        # Step 2: Run LLM notes generator
+        logger.info("Step 2: Generating notes using LLM")
+        if note_numbers:
+            # Generate specific notes
+            result2 = subprocess.run(
+                ["python", "notes/llm_notes_generator.py", "specific", note_numbers],
+                env=env,
+                cwd=cwd,
+                capture_output=True,
+                text=True
+            )
+        else:
+            # Generate all notes
+            result2 = subprocess.run(
+                ["python", "notes/llm_notes_generator.py", "all", ""],
+                env=env,
+                cwd=cwd,
+                capture_output=True,
+                text=True
+            )
+
+        if result2.returncode != 0:
+            return {"status": "error", "error": f"LLM notes generation failed: {result2.stderr}"}
+
+        # Step 3: Convert to Excel
+        logger.info("Step 3: Converting to Excel format")
+        input_json = "data/generated_notes/notes.json"
+        output_excel = "data/generated_notes_excel/notes.xlsx"
+
+        result3 = subprocess.run(
+            ["python", "notes/llm_notes_excel_converter.py", input_json, output_excel],
+            env=env,
+            cwd=cwd,
+            capture_output=True,
+            text=True
+        )
+
+        if result3.returncode == 0:
+            execution_time = round(time.time() - start_time, 2)
+            return {
+                "status": "success",
+                "message": "LLM-based notes generated successfully",
+                "output_xlsx_path": output_excel,
+                "execution_id": execution_id,
+                "execution_time": execution_time
+            }
+        else:
+            execution_time = round(time.time() - start_time, 2)
+            return {
+                "status": "error",
+                "error": f"Excel conversion failed: {result3.stderr}",
+                "execution_id": execution_id,
+                "execution_time": execution_time
+            }
+
+    except Exception as e:
+        execution_time = round(time.time() - start_time, 2)
+        logger.error(f"LLM notes generation failed: {e}")
+        return {
+            "status": "error",
+            "error": f"LLM notes generation failed: {e}",
+            "execution_id": execution_id,
+            "execution_time": execution_time
+        }
+
 # Simplified tool list - only financial statement generation
 FINANCIAL_TOOLS = [
     generate_notes_full_pipeline_from_path,
     generate_balance_sheet,
     generate_pnl_statement,
-    generate_cash_flow_statement
+    generate_cash_flow_statement,
+    generate_llm_notes
 ]

app.py

@@ -1,12 +1,15 @@
-from fastapi import FastAPI, APIRouter, UploadFile, File, HTTPException, Query
+from fastapi import FastAPI, APIRouter, UploadFile, File, HTTPException, Query, Form
 from fastapi.responses import FileResponse
+from typing import Optional
 import os
 import shutil
 import logging
+import json
 from agents.langgraph import run_workflow
 from agents.rlhf_workflows import run_rlhf_workflow
 from agents.rlhf_routes import rlhf_router
 
+
 # Configure logging for the application
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("financial_notes_api")
@@ -31,58 +34,32 @@ async def shutdown_event():
 
 router = APIRouter()
 
-"""@router.post("/new")
-async def llm_generate_and_excel(
-    file: UploadFile = File(...),
-    note_number: Optional[str] = Form(None)
-):
+
+@router.post("/notes-llm")
+async def notes_llm_route(file: UploadFile = File(...), use_rlhf: bool = Query(False)):
+    file_path = f"data/input/{file.filename}"
     os.makedirs("data/input", exist_ok=True)
-    file_location = f"data/input/{file.filename}"
-    with open(file_location, "wb") as buffer:
+    with open(file_path, "wb") as buffer:
         shutil.copyfileobj(file.file, buffer)
-    structured_data = extract_trial_balance_data(file_location)
-    output_json = "data/output1/parsed_trial_balance.json"
-    analyze_and_save_results(structured_data, output_json)
-    try:
-        generator = FlexibleFinancialNoteGenerator()
-    except Exception as e:
-        logger.error(f"Generator init failed: {e}")
-        raise HTTPException(status_code=500, detail=f"Generator init failed: {e}")
-    os.makedirs("data/generated_notes_excel", exist_ok=True)
-    wrapped_json_path = "data/generated_notes/notes_wrapped.json"
-    if note_number:
-        note_numbers = [n.strip() for n in note_number.split(",")]
-        all_notes = []
-        for n in note_numbers:
-            success = generator.generate_note(n, trial_balance_path=output_json)
-            if success:
-                with open("data/generated_notes/notes.json", "r", encoding="utf-8") as f:
-                    note_json = json.load(f)
-                all_notes.append(note_json)
-        with open("data/generated_notes/notes.json", "w", encoding="utf-8") as f:
-            json.dump({"notes": all_notes}, f, indent=2, ensure_ascii=False)
-        wrapped = normalize_llm_notes_json({"notes": all_notes})
-        with open(wrapped_json_path, "w", encoding="utf-8") as f2:
-            json.dump(wrapped, f2, ensure_ascii=False, indent=2)
-        excel_path = "data/generated_notes_excel/notes.xlsx"
-        json_to_xlsx(wrapped_json_path, excel_path)
+    
+    # Choose workflow based on RLHF preference - using "notes-llm" as statement type
+    if use_rlhf:
+        result = run_rlhf_workflow(file_path, "notes-llm")
     else:
-        results = generator.generate_all_notes(trial_balance_path=output_json)
-        if not any(results.values()):
-            logger.error("Failed to generate any notes. LLM API may be down or unreachable.")
-            raise HTTPException(status_code=500, detail="Failed to generate any notes. LLM API may be down or unreachable.")
-        with open("data/generated_notes/notes.json", "r", encoding="utf-8") as f:
-            notes_json = json.load(f)
-        wrapped = normalize_llm_notes_json(notes_json)
-        with open(wrapped_json_path, "w", encoding="utf-8") as f2:
-            json.dump(wrapped, f2, ensure_ascii=False, indent=2)
-        excel_path = "data/generated_notes_excel/notes.xlsx"
-        json_to_xlsx(wrapped_json_path, excel_path)
-    return FileResponse(
-        excel_path,
-        filename=os.path.basename(excel_path),
-        media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-    )"""
+        result = run_workflow(file_path, "notes-llm")
+    
+    if result["status"] == "success":
+        response = FileResponse(result["result"]["output_xlsx_path"], filename=os.path.basename(result["result"]["output_xlsx_path"]))
+        
+        # Add RLHF metadata to headers if available
+        if "rlhf_metadata" in result.get("result", {}):
+            rlhf_data = result["result"]["rlhf_metadata"]
+            response.headers["X-RLHF-Statement-ID"] = str(rlhf_data.get("statement_id", ""))
+            response.headers["X-RLHF-Quality-Score"] = str(rlhf_data.get("predicted_quality", ""))
+            response.headers["X-RLHF-Confidence"] = str(rlhf_data.get("confidence_score", ""))
+        
+        return response
+    raise HTTPException(status_code=500, detail=result["error"])
 
 
 @router.post("/notes")

notes/llm_notes_data_processor.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""
+LLM Notes Data Processor - Extract and analyze trial balance data for LLM notes generation
+"""
+import sys
+import os
+import json
+import logging
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.append(str(Path(__file__).parent.parent))
+
+from notes.data_extraction import extract_trial_balance_data
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def save_trial_balance_data(data, output_path):
+    """Save trial balance data to JSON file"""
+    # Convert TrialBalanceRecord objects to dictionaries
+    records = []
+    for record in data:
+        if hasattr(record, 'model_dump'):
+            records.append(record.model_dump())
+        elif hasattr(record, 'dict'):
+            records.append(record.dict())
+        else:
+            records.append(record)
+
+    output_data = {
+        "trial_balance": records,
+        "metadata": {
+            "total_records": len(records),
+            "source": "llm_notes_data_processor"
+        }
+    }
+
+    with open(output_path, 'w', encoding='utf-8') as f:
+        json.dump(output_data, f, indent=2, ensure_ascii=False)
+
+    logger.info(f"Saved {len(records)} records to {output_path}")
+
+def main():
+    """Main function to process trial balance data for LLM notes generation"""
+    if len(sys.argv) != 2:
+        logger.error("Usage: python llm_notes_data_processor.py <input_file>")
+        sys.exit(1)
+
+    input_file = sys.argv[1]
+
+    if not os.path.exists(input_file):
+        logger.error(f"Input file not found: {input_file}")
+        sys.exit(1)
+
+    try:
+        logger.info(f"Processing trial balance data from: {input_file}")
+
+        # Extract trial balance data
+        structured_data = extract_trial_balance_data(input_file)
+        logger.info("Data extraction completed")
+
+        # Save the data
+        output_json = "data/output1/parsed_trial_balance.json"
+        os.makedirs("data/output1", exist_ok=True)
+        save_trial_balance_data(structured_data, output_json)
+        logger.info(f"Data analysis completed. Results saved to: {output_json}")
+
+        logger.info("LLM notes data processing completed successfully")
+        return 0
+
+    except Exception as e:
+        logger.error(f"Error processing data: {e}")
+        return 1
+
+if __name__ == "__main__":
+    sys.exit(main())

notes/llm_notes_excel_converter.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""
+LLM Notes Excel Converter - Convert JSON notes to Excel format
+"""
+import sys
+import os
+import json
+import logging
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))  # Insert at beginning to prioritize main utils
+
+from utils.utils_normalize import normalize_llm_notes_json
+from notes.json_to_excel import json_to_xlsx
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def main():
+    """Main function to convert LLM-generated notes JSON to Excel"""
+    if len(sys.argv) != 3:
+        logger.error("Usage: python llm_notes_excel_converter.py <input_json> <output_excel>")
+        sys.exit(1)
+
+    input_json = sys.argv[1]
+    output_excel = sys.argv[2]
+
+    if not os.path.exists(input_json):
+        logger.error(f"Input JSON file not found: {input_json}")
+        sys.exit(1)
+
+    try:
+        logger.info(f"Converting notes from {input_json} to {output_excel}")
+
+        # Load the generated notes
+        with open(input_json, "r", encoding="utf-8") as f:
+            notes_data = json.load(f)
+
+        # Normalize the JSON structure
+        wrapped_json_path = "data/generated_notes/notes_wrapped.json"
+        os.makedirs("data/generated_notes", exist_ok=True)
+
+        if isinstance(notes_data, dict) and "notes" in notes_data:
+            # Already in correct format
+            normalized_data = notes_data
+        else:
+            # Wrap in notes structure
+            normalized_data = {"notes": notes_data} if isinstance(notes_data, list) else notes_data
+
+        # Normalize using the utility function
+        wrapped = normalize_llm_notes_json(normalized_data)
+
+        # Save wrapped JSON
+        with open(wrapped_json_path, "w", encoding="utf-8") as f:
+            json.dump(wrapped, f, ensure_ascii=False, indent=2)
+
+        # Convert to Excel
+        os.makedirs(os.path.dirname(output_excel), exist_ok=True)
+        json_to_xlsx(wrapped_json_path, output_excel)
+
+        logger.info(f"Excel conversion completed. Output saved to: {output_excel}")
+        return 0
+
+    except Exception as e:
+        logger.error(f"Error converting to Excel: {e}")
+        return 1
+
+if __name__ == "__main__":
+    sys.exit(main())

notes/llm_notes_generator.py

@@ -115,12 +115,16 @@ class FlexibleFinancialNoteGenerator:
         }
 
     def load_note_templates(self) -> Dict[str, Any]:
-        """Load note templates from app.notes_template.py file."""
+        """Load note templates from notes_template.py file."""
         try:
-            from .notes_template import note_templates
+            # Add parent directory to path for imports when run as script
+            if __name__ == "__main__":
+                sys.path.append(str(Path(__file__).parent.parent))
+
+            from notes_template import note_templates
             return note_templates
         except ImportError as e:
-            logger.error(f"Error importing note_templates from app.notes_template: {e}")
+            logger.error(f"Error importing note_templates from notes_template: {e}")
             return {}
         except Exception as e:
             logger.error(f"Unexpected error loading note_templates: {e}")
@@ -497,32 +501,91 @@ class FlexibleFinancialNoteGenerator:
 def main() -> None:
     """Main function to run the flexible note generator"""
     try:
-        generator = FlexibleFinancialNoteGenerator()
-        if not generator.note_templates:
-            logger.error("No note templates loaded. Check app/new.py")
-            return
-        
-        logger.info(f"Loaded {len(generator.note_templates)} note templates")
-        choice = input("\nGenerate (1) specific note or (2) all notes? Enter 1 or 2: ").strip()
-        
-        if choice == "1":
-            available_notes = list(generator.note_templates.keys())
-            print(f"Available notes: {', '.join(available_notes)}")
-            note_number = input("Enter note number: ").strip()
-            if note_number in available_notes:
-                success = generator.generate_note(note_number)
-                logger.info(f"Note {note_number} {'generated successfully' if success else 'generated with issues'}")
+        # Check for command line arguments
+        if len(sys.argv) > 1:
+            # Command line mode
+            if len(sys.argv) < 3:
+                logger.error("Usage: python llm_notes_generator.py <mode> <note_numbers>")
+                logger.error("  mode: 'specific' or 'all'")
+                logger.error("  note_numbers: comma-separated note numbers (for specific mode)")
+                sys.exit(1)
+
+            mode = sys.argv[1].lower()
+            note_numbers = sys.argv[2] if len(sys.argv) > 2 else ""
+
+            generator = FlexibleFinancialNoteGenerator()
+            if not generator.note_templates:
+                logger.error("No note templates loaded. Check app/new.py")
+                sys.exit(1)
+
+            logger.info(f"Loaded {len(generator.note_templates)} note templates")
+
+            if mode == "specific":
+                if not note_numbers:
+                    logger.error("Note numbers required for specific mode")
+                    sys.exit(1)
+
+                note_list = [n.strip() for n in note_numbers.split(",")]
+                all_notes = []
+
+                for note_number in note_list:
+                    if note_number in generator.note_templates:
+                        success = generator.generate_note(note_number)
+                        if success:
+                            # Load the generated note
+                            with open("data/generated_notes/notes.json", "r", encoding="utf-8") as f:
+                                note_data = json.load(f)
+                            all_notes.append(note_data)
+                            logger.info(f"Note {note_number} generated successfully")
+                        else:
+                            logger.error(f"Failed to generate note {note_number}")
+                    else:
+                        logger.error(f"Note {note_number} not found in templates")
+
+                # Save all notes
+                output_dir = settings.output_dir
+                Path(output_dir).mkdir(parents=True, exist_ok=True)
+                with open(f"{output_dir}/notes.json", "w", encoding="utf-8") as f:
+                    json.dump({"notes": all_notes}, f, indent=2, ensure_ascii=False)
+                logger.info(f"All notes saved to {output_dir}/notes.json")
+
+            elif mode == "all":
+                results = generator.generate_all_notes()
+                successful = sum(1 for success in results.values() if success)
+                total = len(results)
+                logger.info(f"{successful}/{total} notes generated successfully")
             else:
-                logger.error(f"Note {note_number} not found")
-        elif choice == "2":
-            results = generator.generate_all_notes()
-            successful = sum(1 for success in results.values() if success)
-            total = len(results)
-            logger.info(f"{successful}/{total} notes generated successfully")
+                logger.error("Invalid mode. Use 'specific' or 'all'")
+                sys.exit(1)
         else:
-            logger.error("Invalid choice. Enter 1 or 2.")
+            # Interactive mode (original behavior)
+            generator = FlexibleFinancialNoteGenerator()
+            if not generator.note_templates:
+                logger.error("No note templates loaded. Check app/new.py")
+                return
+
+            logger.info(f"Loaded {len(generator.note_templates)} note templates")
+            choice = input("\nGenerate (1) specific note or (2) all notes? Enter 1 or 2: ").strip()
+
+            if choice == "1":
+                available_notes = list(generator.note_templates.keys())
+                print(f"Available notes: {', '.join(available_notes)}")
+                note_number = input("Enter note number: ").strip()
+                if note_number in available_notes:
+                    success = generator.generate_note(note_number)
+                    logger.info(f"Note {note_number} {'generated successfully' if success else 'generated with issues'}")
+                else:
+                    logger.error(f"Note {note_number} not found")
+            elif choice == "2":
+                results = generator.generate_all_notes()
+                successful = sum(1 for success in results.values() if success)
+                total = len(results)
+                logger.info(f"{successful}/{total} notes generated successfully")
+            else:
+                logger.error("Invalid choice. Enter 1 or 2.")
     except Exception as e:
         logger.error(f"Error: {e}", exc_info=True)
+        sys.exit(1)
 
 if __name__ == "__main__":
     main()