agent added, files name changed

.dockerignore

@@ -0,0 +1,64 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+.venv/
+pip-log.txt
+pip-delete-this-directory.txt
+.tox/
+.coverage
+.pytest_cache/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Git
+.git/
+.gitignore
+
+# Documentation
+README.md
+*.md
+docs/
+
+# Environment files (these should be mounted or provided separately)
+.env
+.env.local
+.env.example
+
+# Data directories (these should be mounted as volumes)
+data/input/*
+data/output*/*
+data/csv_notes_*/*
+data/generated_notes*/*
+
+# Logs
+*.log
+logs/
+
+# Docker
+Dockerfile
+docker-compose.yml
+.dockerignore
+
+# Development
+.pytest_cache/
+.coverage
+htmlcov/

.env.example

@@ -0,0 +1,28 @@
+# FinRyver Environment Configuration
+# Copy this file to .env and fill in your actual values
+HFTOKEN=
+OPENROUTER_API_KEY=
+PROJECT_ROOT=
+
+# OpenAI API Configuration (required for LangChain agents)
+OPENAI_API_KEY=your_openai_api_key_here
+
+# LangChain Configuration
+LANGCHAIN_TRACING_V2=false
+LANGCHAIN_API_KEY=your_langsmith_api_key_here
+LANGCHAIN_PROJECT=finryver-agents
+
+# Agent Configuration
+AGENT_MODEL=gpt-4
+AGENT_TEMPERATURE=0.1
+AGENT_MAX_TOKENS=2000
+
+
+# Application Configuration
+DEBUG=false
+LOG_LEVEL=INFO
+
+# File Paths (optional - defaults will be used if not specified)
+DATA_INPUT_PATH=data/input
+DATA_OUTPUT_PATH=data/output
+TEMP_PATH=temp

Dockerfile

@@ -1,49 +1,51 @@
 # Use Python 3.11 as base image
 FROM python:3.11-slim
 
-# -------------------------------
 # Set working directory
 WORKDIR /app
-COPY . .
 
-# -------------------------------
 # Install system dependencies
-RUN ls -l /app
 RUN apt-get update && apt-get install -y \
     build-essential \
     curl \
     git \
     && rm -rf /var/lib/apt/lists/*
 
-# -------------------------------
-# Copy and install Python dependencies
+# Copy and install Python dependencies first (better caching)
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# -------------------------------
-# Optional: Create necessary data directories if not bind-mounted
+# Copy application code
+COPY . .
+
+# Create necessary data directories for financial processing
 RUN mkdir -p /app/data/input \
+    /app/data/output \
     /app/data/output1 \
     /app/data/output2 \
     /app/data/output3 \
     /app/data/csv_notes_bs \
     /app/data/csv_notes_cfs \
     /app/data/csv_notes_pnl \
-    /app/data/output \
-    /app/data/output1 \
-    /app/data/output2 \
-    /app/data/output3 \
+    /app/data/generated_notes \
+    /app/data/generated_notes_excel \
     && chmod -R 777 /app/data
 
-# -------------------------------
 # Set environment variables
 ENV PYTHONPATH=/app
 ENV PYTHONUNBUFFERED=1
 
-# -------------------------------
+# Default agent configuration (can be overridden by .env)
+ENV AGENT_MODEL=gpt-3.5-turbo
+ENV AGENT_TEMPERATURE=0.1
+ENV AGENT_MAX_TOKENS=2000
+
 # Expose the port
 EXPOSE 8000
 
-# -------------------------------
-# Start FastAPI app from app.py
+# Health check for the API
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/docs || exit 1
+
+# Start FastAPI app
 CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -4,14 +4,18 @@
 
 FinRyver is an AI-powered financial statement generation platform that automatically converts trial balance data into comprehensive financial reports including balance sheets, cash flow statements, and profit & loss statements. Built with FastAPI and leveraging Large Language Models (LLMs), it streamlines the financial reporting process for accountants, auditors, and financial professionals by automating the generation of detailed financial notes and statements from structured trial balance inputs.
 
+**New in 2025**: FinRyver now features an intelligent **agentic system** powered by LangChain that provides AI-driven automation, natural language processing, and intelligent decision-making for financial statement generation.
+
 ## 🎯 Key Features
 
 - **Automated Trial Balance Processing**: Upload Excel files containing trial balance data and automatically extract structured financial information
 - **AI-Powered Financial Notes Generation**: Utilize LLMs to generate comprehensive financial notes with detailed explanations and context
+- **Intelligent Agentic System**: LangChain-powered agents that understand natural language instructions and automate complex financial workflows
 - **Multi-Statement Support**: Generate Balance Sheets, Cash Flow Statements, and Profit & Loss statements from the same data source
 - **Excel Output Generation**: Export all generated reports and notes to professional Excel formats
 - **RESTful API Architecture**: Easy integration with existing financial systems through well-documented REST endpoints
 - **Flexible Note Selection**: Generate specific financial notes by number or create comprehensive reports covering all relevant sections
+- **Unified Agent Interface**: Single `/agent/generate` endpoint for intelligent financial statement generation
 
 ## 🏗️ Project Architecture
 
@@ -22,6 +26,11 @@ FinRyver/
 ├── Dockerfile            # Container configuration
 ├── docker-compose.yml    # Multi-container orchestration
 ├── 
+├── agents/               # Agentic system (LangChain)
+│   ├── base_config.py    # Agent configuration and utilities
+│   ├── simple_agent.py   # Financial statement agent
+│   └── simple_tools.py   # LangChain tools for financial processing
+├── 
 ├── bs/                   # Balance Sheet processing modules
 │   ├── bl_llm.py         # Balance sheet LLM integration
 │   ├── csv_json_bs.py    # Balance sheet data conversion
@@ -80,6 +89,8 @@ Trial Balance Upload → Data Extraction → AI Processing → Financial Stateme
 
 ### AI/ML Integration
 - **Large Language Models (LLMs)**: For intelligent financial note generation and analysis
+- **LangChain Framework**: Agentic system for intelligent financial statement processing
+- **OpenRouter API**: Flexible LLM provider integration for AI-powered analysis
 - **Custom AI Pipelines**: Specialized processing for financial data interpretation
 
 ### Infrastructure
@@ -128,6 +139,25 @@ Trial Balance Upload → Data Extraction → AI Processing → Financial Stateme
 | `/bs_from_notes` | POST | Generate balance sheet from existing notes |
 | `/pnl_from_notes` | POST | Generate P&L statement from existing notes |
 | `/cf_from_notes` | POST | Generate cash flow statement from existing notes |
+| `/agent/generate` | POST | **NEW**: Intelligent agent-based financial statement generation |
+
+#### Agentic System Endpoint
+
+**`POST /agent/generate`** - Unified intelligent financial statement generation
+
+**Parameters:**
+- `file`: Trial balance Excel file
+- `note_numbers`: Optional comma-separated note numbers (empty = all notes)
+- `statement_type`: "all", "notes", "balance_sheet", "pnl", or "cash_flow"
+
+**Example Usage:**
+```bash
+curl -X POST "http://localhost:8000/agent/generate" \
+  -H "Content-Type: multipart/form-data" \
+  -F "file=@trial_balance.xlsx" \
+  -F "note_numbers=2,3,4,5" \
+  -F "statement_type=all"
+```
 
 ## 📊 Results & Examples
 
@@ -189,6 +219,27 @@ docker run -p 8000:8000 finryver
 2. **Business Rules**: Modify `config/rules1.json` for custom validation rules
 3. **Account Mapping**: Update `config/mapping1.json` for account categorization
 
+#### Agentic System Configuration
+
+For the intelligent agent features, ensure you have your LLM API key configured:
+
+```env
+# Required for agentic system
+OPENROUTER_API_KEY=your_openrouter_api_key_here
+
+# Optional agent configuration
+AGENT_MODEL=gpt-3.5-turbo
+AGENT_TEMPERATURE=0.1
+AGENT_MAX_TOKENS=2000
+```
+
+**Agent Benefits:**
+- Natural language understanding for financial tasks
+- Intelligent workflow orchestration
+- Unified interface for all financial statements
+- Error recovery and retry logic
+- Contextual financial analysis
+
 ### Usage Examples
 
 #### Generate Complete Financial Report
@@ -234,12 +285,18 @@ python -m pytest tests/ --verbose
 
 ## 🔮 Future Roadmap
 
+### Completed Features ✅
+- **Intelligent Agentic System**: LangChain-powered agents with natural language processing
+- **Unified Agent Interface**: Single endpoint for all financial statement generation
+- **Optional Note Numbers**: Flexible note generation (specific or all notes)
+
 ### Planned Features
 - **Multi-Currency Support**: Handle international financial statements
 - **Advanced AI Models**: Integration with latest financial AI models
 - **Real-time Processing**: WebSocket support for live data updates
 - **Audit Trail**: Comprehensive logging and change tracking
 - **Custom Templates**: User-defined financial statement templates
+- **Agent Conversation History**: Multi-turn conversations with financial agents
 
 ### Known Limitations
 - Currently supports Excel input formats only

agents/__init__.py

@@ -0,0 +1 @@
+# Agent framework for FinRyver

agents/base_config.py

@@ -0,0 +1,106 @@
+"""
+Base configuration and utilities for LangChain agents in FinRyver
+"""
+import os
+from typing import Optional
+from langchain_openai import ChatOpenAI
+from langchain.agents import AgentExecutor, create_openai_tools_agent
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain.tools import Tool
+from langchain_core.messages import HumanMessage, SystemMessage
+import logging
+
+# Load environment variables
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass  # dotenv is optional
+
+logger = logging.getLogger(__name__)
+
+class FinRyverAgentConfig:
+    """Configuration class for FinRyver agents"""
+    
+    def __init__(self):
+        self.openrouter_api_key = os.getenv("OPENROUTER_API_KEY")
+        self.model_name = os.getenv("AGENT_MODEL", "gpt-3.5-turbo")
+        self.temperature = float(os.getenv("AGENT_TEMPERATURE", "0.1"))
+        self.max_tokens = int(os.getenv("AGENT_MAX_TOKENS", "2000"))
+        
+    def get_llm(self) -> ChatOpenAI:
+        """Get configured LLM instance"""
+        if not self.openrouter_api_key:
+            logger.warning("OPENROUTER_API_KEY not found. Agent functionality may be limited.")
+            return None
+            
+        return ChatOpenAI(
+            api_key=self.openrouter_api_key,
+            base_url="https://openrouter.ai/api/v1",
+            model=self.model_name,
+            temperature=self.temperature,
+            max_tokens=self.max_tokens
+        )
+
+def create_financial_agent_prompt(role: str, goal: str, context: str = "") -> ChatPromptTemplate:
+    """Create a standardized prompt template for financial agents"""
+    
+    system_message = f"""
+    You are a {role} working with financial data analysis and reporting.
+    
+    Your primary goal: {goal}
+    
+    Context: {context}
+    
+    You have access to various tools to help you analyze financial data, generate reports, 
+    and ensure compliance with accounting standards. Always provide clear, accurate, and 
+    professional responses.
+    
+    When working with financial data:
+    - Ensure all calculations are accurate
+    - Follow GAAP/IFRS standards where applicable
+    - Provide clear explanations for your analysis
+    - Flag any anomalies or inconsistencies
+    - Always validate data before proceeding
+    
+    If you need clarification or additional information, ask specific questions.
+    """
+    
+    return ChatPromptTemplate.from_messages([
+        ("system", system_message),
+        MessagesPlaceholder(variable_name="chat_history", optional=True),
+        ("human", "{input}"),
+        MessagesPlaceholder(variable_name="agent_scratchpad")
+    ])
+
+def create_agent_executor(
+    role: str, 
+    goal: str, 
+    tools: list, 
+    context: str = "",
+    llm: Optional[ChatOpenAI] = None
+) -> AgentExecutor:
+    """Create a configured agent executor"""
+    
+    if llm is None:
+        config = FinRyverAgentConfig()
+        llm = config.get_llm()
+        
+    if llm is None:
+        raise ValueError("LLM configuration failed. Check your API keys.")
+    
+    prompt = create_financial_agent_prompt(role, goal, context)
+    
+    agent = create_openai_tools_agent(
+        llm=llm,
+        tools=tools,
+        prompt=prompt
+    )
+    
+    return AgentExecutor(
+        agent=agent,
+        tools=tools,
+        verbose=True,
+        max_iterations=5,
+        early_stopping_method="generate"
+    )

agents/simple_agent.py

@@ -0,0 +1,69 @@
+"""
+Simplified financial agent focused only on generating financial statements
+"""
+from typing import Dict, Any, Optional
+import logging
+from .base_config import FinRyverAgentConfig, create_agent_executor
+from .simple_tools import FINANCIAL_TOOLS
+
+logger = logging.getLogger(__name__)
+
+class FinancialStatementAgent:
+    """
+    Simple agent that generates: Notes, Balance Sheet, P&L, Cash Flow
+    """
+    
+    def __init__(self, config: Optional[FinRyverAgentConfig] = None):
+        self.config = config or FinRyverAgentConfig()
+        self.llm = self.config.get_llm()
+        
+        # Create agent with financial statement tools
+        self.agent_executor = create_agent_executor(
+            role="Financial Statement Generator",
+            goal="Generate financial statements (notes, balance sheet, P&L, cash flow) from trial balance data",
+            tools=FINANCIAL_TOOLS,
+            context="You generate financial statements from trial balance files. Available outputs: Notes, Balance Sheet, P&L Statement, Cash Flow Statement.",
+            llm=self.llm
+        )
+    
+    async def generate_all_statements(self, file_path: str, note_numbers: str) -> Dict[str, Any]:
+        """Generate all financial statements from trial balance file"""
+        try:
+            prompt = f"""
+            Generate all financial statements from the trial balance file: {file_path}
+            Note numbers to include: {note_numbers}
+            
+            Please generate in this order:
+            1. Financial notes for note numbers: {note_numbers}
+            2. Balance sheet
+            3. P&L statement  
+            4. Cash flow statement
+            
+            Use the available tools to generate each statement and provide a summary of what was created.
+            """
+            
+            result = await self.agent_executor.ainvoke({"input": prompt})
+            return {"status": "success", "result": result["output"]}
+            
+        except Exception as e:
+            logger.error(f"Error generating statements: {e}")
+            return {"status": "error", "error": str(e)}
+    
+    async def generate_specific_statement(self, file_path: str, statement_type: str, note_numbers: str) -> Dict[str, Any]:
+        """Generate a specific financial statement"""
+        try:
+            prompts = {
+                "notes": f"Generate financial notes 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}"
+            }
+            
+            prompt = prompts.get(statement_type, prompts["notes"])
+            
+            result = await self.agent_executor.ainvoke({"input": prompt})
+            return {"status": "success", "result": result["output"]}
+            
+        except Exception as e:
+            logger.error(f"Error generating {statement_type}: {e}")
+            return {"status": "error", "error": str(e)}

agents/simple_tools.py

@@ -0,0 +1,395 @@
+"""
+Simplified LangChain tools for FinRyver financial statement generation
+Focus: Notes, Balance Sheet, P&L, Cash Flow generation only
+"""
+from langchain_core.tools import tool
+import os
+import subprocess
+import json
+import shutil
+import time
+import uuid
+from typing import Dict, Any
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+@tool
+def generate_notes_from_trial_balance(file_path: str, note_numbers: str = "") -> Dict[str, Any]:
+    """
+    Generate financial notes from trial balance file
+    Args:
+        file_path: Path to the trial balance Excel file
+        note_numbers: Optional comma-separated note numbers (e.g., "2,3,4,5"). If empty, generates all notes.
+    """
+    execution_id = str(uuid.uuid4())[:8]
+    start_time = time.time()
+    tool_name = "generate_notes_from_trial_balance"
+
+    try:
+        
+    # Copy file to input directory
+        input_dir = "data/input"
+        os.makedirs(input_dir, exist_ok=True)
+        input_file = os.path.join(input_dir, "trial_balance.xlsx")
+        shutil.copy2(file_path, input_file)
+        
+        file_size = os.path.getsize(input_file)
+        
+        
+        # Run notes generation using existing endpoint logic
+        env = os.environ.copy()
+        
+       
+        # Use existing notes generation modules
+        from notes.data_extraction import extract_trial_balance_data
+        from notes.llm_notes_generator import FlexibleFinancialNoteGenerator
+        from notes.json_to_excel import json_to_xlsx
+        
+       
+        # Extract trial balance data
+        trial_balance_data = extract_trial_balance_data(file_path)
+        
+      
+       
+        # Generate notes
+        note_generator = FlexibleFinancialNoteGenerator()
+        
+        if note_numbers.strip():
+            # Generate specific notes
+            note_list = [int(n.strip()) for n in note_numbers.split(',')]
+            generated_notes = {}
+            for i, note_num in enumerate(note_list, 1):
+                note_content = note_generator.generate_note(note_num, trial_balance_data)
+                generated_notes[f"note_{note_num}"] = note_content
+            message = f"Notes generated for: {note_numbers}"
+        else:
+            # Generate all notes
+            generated_notes = note_generator.generate_all_notes(trial_balance_data)
+            message = "All notes generated successfully"    
+        # Save notes
+        output_path = "data/generated_notes/notes.json"
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        with open(output_path, 'w') as f:
+            json.dump(generated_notes, f, indent=2)
+        
+        execution_time = round(time.time() - start_time, 2)
+        output_file_size = os.path.getsize(output_path)
+    
+        return {
+            "status": "success",
+            "message": message,
+            "output_path": output_path,
+            "execution_id": execution_id,
+            "execution_time": execution_time
+        }
+            
+    except Exception as e:
+        execution_time = round(time.time() - start_time, 2)
+       
+        return {
+            "status": "error", 
+            "error": str(e), 
+            "execution_id": execution_id,
+            "execution_time": execution_time
+        }
+
+@tool
+def generate_balance_sheet(file_path: str) -> Dict[str, Any]:
+    """
+    Generate balance sheet from trial balance file using complete pipeline
+    Args:
+        file_path: Path to trial balance Excel file
+    """
+    execution_id = str(uuid.uuid4())[:8]
+    start_time = time.time()
+    tool_name = "generate_balance_sheet"
+    
+
+    try:
+        # Use the complete BS pipeline from the existing endpoint
+        env = os.environ.copy()
+        if os.getenv("OPENROUTER_API_KEY"):
+            env["OPENROUTER_API_KEY"] = os.getenv("OPENROUTER_API_KEY")
+        env["INPUT_FILE"] = "data/clean_financial_data_bs.json"
+        cwd = os.getcwd()
+        
+        # Step 1: Run balance_sheet_data_extractor.py
+
+        result1 = subprocess.run(
+            ["python", "bs/balance_sheet_data_extractor.py", file_path],
+            env=env,
+            cwd=cwd,
+            capture_output=True,
+            text=True
+        )
+        
+        if result1.returncode != 0:
+
+            return {"status": "error", "error": f"Balance sheet data extraction failed: {result1.stderr}"}
+        
+        # Step 2: Run balance_sheet_csv_to_json_converter.py
+
+        
+        result2 = subprocess.run(
+            ["python", "bs/balance_sheet_csv_to_json_converter.py"],
+            env=env,
+            cwd=cwd,
+            capture_output=True,
+            text=True
+        )
+        
+        if result2.returncode != 0:
+        
+            return {"status": "error", "error": f"CSV to JSON conversion failed: {result2.stderr}"}
+        
+        # Step 3: Run balance_sheet_generator.py
+       
+        result3 = subprocess.run(
+            ["python", "bs/balance_sheet_generator.py"],
+            env=env,
+            cwd=cwd,
+            capture_output=True,
+            text=True
+        )
+        
+        if result3.returncode == 0:
+            # Check for output files in data/output directory
+            output_files = []
+            if os.path.exists("data/output"):
+                output_files = [f for f in os.listdir("data/output") if f.endswith('.xlsx')]
+            
+            execution_time = round(time.time() - start_time, 2)
+            
+  
+            return {
+                "status": "success",
+                "message": "Balance sheet generated successfully",
+                "output_path": "data/output/",
+                "output_files": output_files,
+                "execution_id": execution_id,
+                "execution_time": execution_time
+            }
+        else:
+            execution_time = round(time.time() - start_time, 2)
+
+            return {
+                "status": "error", 
+                "error": f"Balance sheet generation failed: {result3.stderr}",
+                "execution_id": execution_id
+            }
+            
+    except Exception as e:
+        execution_time = round(time.time() - start_time, 2)
+    
+        return {
+            "status": "error", 
+            "error": str(e), 
+            "execution_id": execution_id,
+            "execution_time": execution_time
+        }
+
+@tool  
+def generate_pnl_statement(file_path: str) -> Dict[str, Any]:
+    """
+    Generate P&L statement from trial balance file using complete pipeline
+    Args:
+        file_path: Path to trial balance Excel file  
+    """
+    execution_id = str(uuid.uuid4())[:8]
+    start_time = time.time()
+    tool_name = "generate_pnl_statement"
+    
+    
+    try:
+        # Use the complete P&L pipeline from existing endpoint
+        env = os.environ.copy()
+        if os.getenv("OPENROUTER_API_KEY"):
+            env["OPENROUTER_API_KEY"] = os.getenv("OPENROUTER_API_KEY")
+        env["INPUT_FILE"] = "data/clean_financial_data_pnl.json"
+        cwd = os.getcwd()
+        
+        # Step 1: Run profit_loss_data_extractor.py  
+
+        result1 = subprocess.run(
+            ["python", "pnl/profit_loss_data_extractor.py", file_path],
+            env=env,
+            cwd=cwd,
+            capture_output=True,
+            text=True
+        )
+        
+        if result1.returncode != 0:
+      
+            return {"status": "error", "error": f"P&L data extraction failed: {result1.stderr}"}
+        
+        # Step 2: Run profit_loss_csv_to_json_converter.py
+     
+        
+        result2 = subprocess.run(
+            ["python", "pnl/profit_loss_csv_to_json_converter.py"],
+            env=env,
+            cwd=cwd,
+            capture_output=True,
+            text=True
+        )
+        
+        if result2.returncode != 0:
+   
+            return {"status": "error", "error": f"P&L CSV to JSON conversion failed: {result2.stderr}"}
+        
+        # Step 3: Run profit_loss_statement_generator.py
+
+        result3 = subprocess.run(
+            ["python", "pnl/profit_loss_statement_generator.py", "data/clean_financial_data_pnl.json"],
+            env=env,
+            cwd=cwd,
+            capture_output=True,
+            text=True
+        )
+        
+        if result3.returncode == 0:
+            execution_time = round(time.time() - start_time, 2)
+            output_path = "data/pnl_statement.xlsx"
+   
+            return {
+                "status": "success", 
+                "message": "P&L statement generated successfully",
+                "output_path": output_path,
+                "execution_id": execution_id,
+                "execution_time": execution_time
+            }
+        else:
+            execution_time = round(time.time() - start_time, 2)
+    
+            return {
+                "status": "error",
+                "error": f"P&L generation failed: {result3.stderr}",
+                "execution_id": execution_id
+            }
+            
+    except Exception as e:
+        execution_time = round(time.time() - start_time, 2)
+   
+        return {
+            "status": "error", 
+            "error": str(e), 
+            "execution_id": execution_id,
+            "execution_time": execution_time
+        }
+
+@tool
+def generate_cash_flow_statement(file_path: str) -> Dict[str, Any]:
+    """
+    Generate cash flow statement from trial balance file using complete pipeline
+    Args:
+        file_path: Path to trial balance Excel file
+    """
+    execution_id = str(uuid.uuid4())[:8]
+    start_time = time.time()
+    tool_name = "generate_cash_flow_statement"
+    
+  
+    
+    try:
+        # Use the complete CF pipeline from existing endpoint  
+        env = os.environ.copy()
+        if os.getenv("OPENROUTER_API_KEY"):
+            env["OPENROUTER_API_KEY"] = os.getenv("OPENROUTER_API_KEY")
+        env["INPUT_FILE"] = "data/clean_financial_data_cfs.json"
+        cwd = os.getcwd()
+        
+        # Step 1: Run cash_flow_data_extractor.py
+    
+        
+        result1 = subprocess.run(
+            ["python", "cf/cash_flow_data_extractor.py", file_path],
+            env=env,
+            cwd=cwd,
+            capture_output=True,
+            text=True
+        )
+        
+        if result1.returncode != 0:
+      
+            return {"status": "error", "error": f"Cash flow data extraction failed: {result1.stderr}"}
+        
+        # Step 2: Run cash_flow_csv_to_json_converter.py
+     
+        
+        result2 = subprocess.run(
+            ["python", "cf/cash_flow_csv_to_json_converter.py"],
+            env=env,
+            cwd=cwd,
+            capture_output=True,
+            text=True
+        )
+        
+        if result2.returncode != 0:
+            
+            return {"status": "error", "error": f"Cash flow CSV to JSON conversion failed: {result2.stderr}"}
+        
+        # Step 3: Run cash_flow_data_processor.py
+   
+        
+        result3 = subprocess.run(
+            ["python", "cf/cash_flow_data_processor.py"],
+            env=env,
+            cwd=cwd,
+            capture_output=True,
+            text=True
+        )
+        
+        if result3.returncode != 0:
+          
+            return {"status": "error", "error": f"Cash flow data processing failed: {result3.stderr}"}
+        
+        # Step 4: Run cash_flow_statement_generator.py
+     
+        
+        result4 = subprocess.run(
+            ["python", "cf/cash_flow_statement_generator.py"],
+            env=env,
+            cwd=cwd,
+            capture_output=True,
+            text=True
+        )
+        
+        if result4.returncode == 0:
+            execution_time = round(time.time() - start_time, 2)
+            output_path = "data/cash_flow_statements.xlsx"
+     
+            return {
+                "status": "success",
+                "message": "Cash flow statement generated successfully", 
+                "output_path": output_path,
+                "execution_id": execution_id,
+                "execution_time": execution_time
+            }
+        else:
+            execution_time = round(time.time() - start_time, 2)
+        
+            return {
+                "status": "error",
+                "error": f"Cash flow generation failed: {result4.stderr}",
+                "execution_id": execution_id
+            }
+            
+    except Exception as e:
+        execution_time = round(time.time() - start_time, 2)
+      
+        return {
+            "status": "error", 
+            "error": str(e), 
+            "execution_id": execution_id,
+            "execution_time": execution_time
+        }
+
+# Simplified tool list - only financial statement generation
+FINANCIAL_TOOLS = [
+    generate_notes_from_trial_balance,
+    generate_balance_sheet,
+    generate_pnl_statement,
+    generate_cash_flow_statement
+]

app.py

@@ -17,11 +17,13 @@ from notes.notes_generator import process_json
 from notes.json_to_excel import json_to_xlsx
 from utils.utils_normalize import normalize_llm_note_json, normalize_llm_notes_json
 
-
 # Configure logging for the application
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("financial_notes_api")
 
+# Import agent system
+from agents.simple_agent import FinancialStatementAgent
+
 app = FastAPI(
     title="Financial Notes Generator API",
     description="API for generating financial notes, balance sheets, cash flow statements, and P&L reports.",
@@ -213,14 +215,14 @@ async def bs_from_notes(file: UploadFile = File(...)):
         env["OPENROUTER_API_KEY"] = os.getenv("OPENROUTER_API_KEY")
     env["INPUT_FILE"] = "data/clean_financial_data_bs.json"
     cwd = os.getenv("PROJECT_ROOT", os.getcwd())
-    # Run sircodebs.py
-    run_subprocess("bs/sircodebs.py", [input_excel_path], env, cwd)
+    # Run Balance Sheet Data Extractor
+    run_subprocess("bs/balance_sheet_data_extractor.py", [input_excel_path], env, cwd)
     logger.info(f"Files in data/csv_notes_bs/: {os.listdir('data/csv_notes_bs') if os.path.exists('data/csv_notes_bs') else 'data/csv_notes_bs does not exist'}")
-    # Run csv_json_bs.py
-    run_subprocess("bs/csv_json_bs.py", [], env, cwd)
+    # Run Balance Sheet CSV to JSON Converter
+    run_subprocess("bs/balance_sheet_csv_to_json_converter.py", [], env, cwd)
     logger.info(f"data/clean_financial_data_bs.json exists: {os.path.exists('data/clean_financial_data_bs.json')}")
-    # Run bl_llm.py
-    result = run_subprocess("bs/bl_llm.py", [], env, cwd)
+    # Run Balance Sheet Generator
+    result = run_subprocess("bs/balance_sheet_generator.py", [], env, cwd)
     output_file = extract_output_file(result.stdout)
     if output_file and not os.path.isabs(output_file):
         output_file_path = os.path.join(cwd, output_file)
@@ -228,8 +230,8 @@ async def bs_from_notes(file: UploadFile = File(...)):
         output_file_path = output_file
     if not output_file or not os.path.exists(output_file_path):
         debug_msg = f"\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
-        logger.error(f"Could not determine output file from bl_llm.py output.{debug_msg}")
-        raise HTTPException(status_code=500, detail=f"Could not determine output file from bl_llm.py output.{debug_msg}")
+        logger.error(f"Could not determine output file from balance_sheet_generator.py output.{debug_msg}")
+        raise HTTPException(status_code=500, detail=f"Could not determine output file from balance_sheet_generator.py output.{debug_msg}")
     logger.info(f"Pipeline completed. Output file: {output_file_path}")
     return FileResponse(
         output_file_path,
@@ -250,16 +252,16 @@ async def pnl_from_notes(file: UploadFile = File(...)):
         env["OPENROUTER_API_KEY"] = os.getenv("OPENROUTER_API_KEY")
     env["INPUT_FILE"] = "data/clean_financial_data_pnl.json"
     cwd = os.getenv("PROJECT_ROOT", os.getcwd())
-    # Run sircodepnl.py
-    run_subprocess("pnl/sircodepnl.py", [input_excel_path], env, cwd)
+    # Run Profit & Loss Data Extractor
+    run_subprocess("pnl/profit_loss_data_extractor.py", [input_excel_path], env, cwd)
     csv_notes_pnl_path = os.path.join(cwd, 'data/csv_notes_pnl')
     logger.info(f"Files in {csv_notes_pnl_path}/: {os.listdir(csv_notes_pnl_path) if os.path.exists(csv_notes_pnl_path) else f'{csv_notes_pnl_path} does not exist'}")
-    # Run csv_json_pnl.py
-    run_subprocess("pnl/csv_json_pnl.py", [], env, cwd)
+    # Run Profit & Loss CSV to JSON Converter
+    run_subprocess("pnl/profit_loss_csv_to_json_converter.py", [], env, cwd)
     json_path = os.path.join(cwd, 'data/clean_financial_data_pnl.json')
     logger.info(f"data/clean_financial_data_pnl.json exists: {os.path.exists(json_path)}")
-    # Run pnl_note.py
-    run_subprocess("pnl/pnl_note.py", [], env, cwd)
+    # Run Profit & Loss Statement Generator
+    run_subprocess("pnl/profit_loss_statement_generator.py", [], env, cwd)
     # Use fixed output file path
     output_file_path = os.path.join(cwd, "data/pnl_statement.xlsx")
     if not os.path.exists(output_file_path):
@@ -282,20 +284,20 @@ async def cf_from_notes(file: UploadFile = File(...)):
     logger.info(f"Files in data/input/: {os.listdir('data/input')}")
     env = os.environ.copy()
     cwd = os.getenv("PROJECT_ROOT", os.getcwd())
-    # Step 1: Run sircodecf.py
-    run_subprocess("cf/sircodecf.py", [input_excel_path], env, cwd)
+    # Step 1: Run Cash Flow Data Extractor
+    run_subprocess("cf/cash_flow_data_extractor.py", [input_excel_path], env, cwd)
     csv_notes_cfs_path = os.path.join(cwd, 'data/csv_notes_cfs')
     logger.info(f"Files in {csv_notes_cfs_path}/: {os.listdir(csv_notes_cfs_path) if os.path.exists(csv_notes_cfs_path) else f'{csv_notes_cfs_path} does not exist'}")
-    # Step 2: Run csv_json_cf.py
-    run_subprocess("cf/csv_json_cf.py", [], env, cwd)
+    # Step 2: Run Cash Flow CSV to JSON Converter
+    run_subprocess("cf/cash_flow_csv_to_json_converter.py", [], env, cwd)
     json_path = os.path.join(cwd, 'data/clean_financial_data_cfs.json')
     logger.info(f"data/clean_financial_data_cfs.json exists: {os.path.exists(json_path)}")
-    # Step 3: Run cf_middlestep.py
-    run_subprocess("cf/cf_middlestep.py", [], env, cwd)
+    # Step 3: Run Cash Flow Data Processor
+    run_subprocess("cf/cash_flow_data_processor.py", [], env, cwd)
     extracted_json_path = os.path.join(cwd, 'data/extracted_cfs_data.json')
     logger.info(f"data/extracted_cfs_data.json exists: {os.path.exists(extracted_json_path)}")
-    # Step 4: Run cf_generation.py
-    result = run_subprocess("cf/cf_generation.py", [], env, cwd)
+    # Step 4: Run Cash Flow Statement Generator
+    result = run_subprocess("cf/cash_flow_statement_generator.py", [], env, cwd)
     output_file = "data/cash_flow_statements.xlsx"
     output_file_path = os.path.join(cwd, output_file)
     if not os.path.exists(output_file_path):
@@ -311,6 +313,45 @@ async def cf_from_notes(file: UploadFile = File(...)):
         media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
     )
 
+@router.post("/agent/generate")
+async def agent_generate_statements(
+    file: UploadFile = File(...),
+    note_numbers: str = Form(""),
+    statement_type: str = Form("all")  # all, notes, balance_sheet, pnl, cash_flow
+):
+    """
+    Use AI agent to generate financial statements (Notes/BS/P&L/CF)
+    """
+    try:
+        # Save uploaded file
+        upload_dir = "data/input"
+        os.makedirs(upload_dir, exist_ok=True)
+        file_path = os.path.join(upload_dir, file.filename)
+        
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+        
+        # Initialize financial statement agent
+        agent = FinancialStatementAgent()
+        
+        # Generate requested statements
+        if statement_type == "all":
+            result = await agent.generate_all_statements(file_path, note_numbers)
+        else:
+            result = await agent.generate_specific_statement(file_path, statement_type, note_numbers)
+        
+        return JSONResponse(content={
+            "message": f"Financial statement generation completed: {statement_type}",
+            "file_processed": file.filename,
+            "note_numbers": note_numbers,
+            "statement_type": statement_type,
+            "result": result
+        })
+        
+    except Exception as e:
+        logger.error(f"Error in agent statement generation: {e}")
+        raise HTTPException(status_code=500, detail=f"Agent generation failed: {str(e)}")
+
 app.include_router(router)
 
 if __name__ == "__main__":

docker-compose.yml

@@ -1,14 +1,37 @@
+version: '3.8'
+
 services:
-  app:
+  finryver:
     build: .
-    container_name: FinRyver
-    volumes:
-      - .:/app
+    container_name: finryver-app
     ports:
       - "8000:8000"
+    volumes:
+      # Mount data directory for persistent storage
+      - ./data:/app/data
+      # Mount config directory for business rules
+      - ./config:/app/config
     environment:
       - PYTHONUNBUFFERED=1
       - PORT=8000
+      # Default agent settings (override with .env file)
+      - AGENT_MODEL=gpt-3.5-turbo
+      - AGENT_TEMPERATURE=0.1
+      - AGENT_MAX_TOKENS=2000
     env_file:
       - .env
-    restart: unless-stopped
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8000/docs"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+
+  # Optional: Add Redis for caching (future enhancement)
+  # redis:
+  #   image: redis:7-alpine
+  #   container_name: finryver-redis
+  #   ports:
+  #     - "6379:6379"
+  #   restart: unless-stopped

requirements.txt

@@ -6,4 +6,11 @@ python-dotenv
 pydantic-settings
 pydantic
 requests
-python-multipart
+python-multipart
+
+# LangChain dependencies
+langchain
+langchain-openai
+langchain-community
+langchain-core
+langsmith