chore: Clean up repo - remove redundant tests and docs, update README

- Remove old test files from root (moved to tests/)
- Remove redundant documentation files
- Update README with new features (rate limiting, stats, PydanticAI)
- Keep HF header clean
- Add PydanticAI integration to project structure

.rebuild_trigger

@@ -1 +0,0 @@
-Mon Nov 17 16:59:47 CET 2025

CHANGES_SUMMARY.md

@@ -1,312 +0,0 @@
-# Changes Summary - Critical Issues Fixed
-
-## Overview
-This document summarizes all the critical fixes and improvements implemented based on the code review.
-
----
-
-## ✅ Critical Issues Fixed
-
-### 1. Model Readiness Check in Health Endpoint
-**File:** `app/main.py`
-
-**Before:**
-```python
-@app.get("/health")
-async def health() -> Dict[str, str]:
-    return {"status": "healthy", "service": "LLM Pro Finance API"}
-```
-
-**After:**
-```python
-@app.get("/health")
-async def health() -> Dict[str, Any]:
-    model_ready = _initialized and model is not None
-    return {
-        "status": "healthy" if model_ready else "initializing",
-        "service": "LLM Pro Finance API",
-        "model_ready": model_ready,
-    }
-```
-
-**Impact:** Health endpoint now accurately reports whether the model is ready to serve requests.
-
----
-
-### 2. Error Message Sanitization
-**Files:** `app/routers/openai_api.py`
-
-**Changes:**
-- Separated `ValueError` (validation errors) from generic exceptions
-- Sanitized internal error messages to prevent information leakage
-- Added specific error handling for model reload endpoint
-
-**Before:**
-```python
-except Exception as e:
-    return JSONResponse(
-        status_code=500,
-        content={"error": {"message": str(e), "type": "internal_error"}}
-    )
-```
-
-**After:**
-```python
-except ValueError as e:
-    # Validation errors - safe to expose
-    return JSONResponse(
-        status_code=400,
-        content={"error": {"message": str(e), "type": "invalid_request_error"}}
-    )
-except Exception as e:
-    # Internal errors - sanitize message
-    logger.error(f"Error: {str(e)}", exc_info=True)
-    return JSONResponse(
-        status_code=500,
-        content={"error": {"message": "An internal error occurred. Please try again later.", "type": "internal_error"}}
-    )
-```
-
-**Impact:** Prevents sensitive information from being exposed to clients.
-
----
-
-### 3. Magic Numbers Extracted to Constants
-**File:** `app/utils/constants.py`
-
-**Added:**
-```python
-# Model initialization constants
-MODEL_INIT_TIMEOUT_SECONDS = 300  # 5 minutes
-MODEL_INIT_WAIT_INTERVAL_SECONDS = 1
-
-# Rate limiting constants
-RATE_LIMIT_REQUESTS_PER_MINUTE = 30
-RATE_LIMIT_REQUESTS_PER_HOUR = 500
-
-# Confidence calculation constants
-MIN_ANSWER_LENGTH_FOR_HIGH_CONFIDENCE = 50
-```
-
-**Updated:** `app/providers/transformers_provider.py` to use these constants instead of hardcoded values.
-
-**Impact:** Better maintainability and easier configuration.
-
----
-
-### 4. Fixed Duplicate Regex
-**File:** `open-finance-pydanticAI/app/utils.py`
-
-**Before:** Duplicate regex pattern applied twice unnecessarily.
-
-**After:** Removed duplicate, keeping only one application.
-
-**Impact:** Cleaner code, slight performance improvement.
-
----
-
-## 🆕 New Features
-
-### 5. Rate Limiting
-**Files:** 
-- `app/middleware/rate_limit.py` (new)
-- `app/middleware/__init__.py` (new)
-- `app/main.py` (updated)
-
-**Features:**
-- Simple in-memory rate limiter (suitable for demo/single user)
-- Per-minute limit: 30 requests
-- Per-hour limit: 500 requests
-- Rate limit headers in responses:
-  - `X-RateLimit-Limit-Minute`
-  - `X-RateLimit-Limit-Hour`
-  - `X-RateLimit-Remaining-Minute`
-  - `X-RateLimit-Remaining-Hour`
-- Automatic cleanup of old entries to prevent memory growth
-- Returns 429 status with `Retry-After` header when limit exceeded
-
-**Usage:** Automatically applied to all API endpoints except public ones (`/`, `/health`, `/docs`, `/v1/stats`).
-
----
-
-### 6. Token Statistics Tracking
-**Files:**
-- `app/utils/stats.py` (new)
-- `app/providers/transformers_provider.py` (updated)
-- `app/main.py` (updated)
-
-**Features:**
-- Thread-safe statistics tracking
-- Tracks per-request:
-  - Prompt tokens
-  - Completion tokens
-  - Total tokens
-  - Model used
-  - Finish reason
-  - Timestamp
-
-**Aggregate Statistics:**
-- Total requests
-- Total tokens (prompt, completion, total)
-- Average tokens per request
-- Requests per hour
-- Tokens per hour
-- Requests by model
-- Tokens by model
-- Finish reason distribution
-- Uptime tracking
-
-**New Endpoint:** `GET /v1/stats`
-Returns comprehensive usage statistics and token counts.
-
-**Example Response:**
-```json
-{
-  "uptime_seconds": 3600,
-  "uptime_hours": 1.0,
-  "total_requests": 50,
-  "total_prompt_tokens": 5000,
-  "total_completion_tokens": 15000,
-  "total_tokens": 20000,
-  "average_prompt_tokens": 100.0,
-  "average_completion_tokens": 300.0,
-  "average_total_tokens": 400.0,
-  "requests_per_hour": 50.0,
-  "tokens_per_hour": 20000.0,
-  "requests_by_model": {
-    "DragonLLM/qwen3-8b-fin-v1.0": 50
-  },
-  "tokens_by_model": {
-    "DragonLLM/qwen3-8b-fin-v1.0": 20000
-  },
-  "finish_reasons": {
-    "stop": 45,
-    "length": 5
-  },
-  "recent_requests_count": 50
-}
-```
-
----
-
-### 7. Improved Token Counting Accuracy
-**File:** `app/providers/transformers_provider.py`
-
-**Changes:**
-- Non-streaming: Uses `len(inputs.input_ids[0])` for prompt tokens (more accurate)
-- Streaming: Uses tokenizer to count tokens from generated text after streaming completes
-
-**Before:**
-```python
-prompt_tokens = inputs.input_ids.shape[1]  # Less accurate
-completion_tokens = len(generated_ids)  # OK but could be better
-```
-
-**After:**
-```python
-prompt_tokens = len(inputs.input_ids[0])  # More accurate
-# For streaming:
-completion_tokens = len(tokenizer.encode(generated_text, add_special_tokens=False))
-```
-
-**Impact:** More accurate token counting for billing/statistics.
-
----
-
-## 📊 Statistics Tracking
-
-### What's Tracked
-- Every chat completion request (streaming and non-streaming)
-- Token usage per request
-- Model usage patterns
-- Finish reasons (stop vs length)
-- Request rates
-
-### Statistics Endpoint
-- **URL:** `GET /v1/stats`
-- **Access:** Public (no authentication required)
-- **Rate Limited:** No (excluded from rate limiting)
-
----
-
-## 🔒 Security Improvements
-
-1. **Error Message Sanitization:** Internal errors no longer expose sensitive details
-2. **Rate Limiting:** Prevents abuse and resource exhaustion
-3. **Input Validation:** Better separation of validation vs internal errors
-
----
-
-## 📝 Files Modified
-
-### New Files
-- `app/middleware/rate_limit.py` - Rate limiting middleware
-- `app/middleware/__init__.py` - Middleware package init
-- `app/utils/stats.py` - Statistics tracking module
-- `CHANGES_SUMMARY.md` - This file
-
-### Modified Files
-- `app/main.py` - Health check, stats endpoint, middleware setup
-- `app/routers/openai_api.py` - Error sanitization
-- `app/providers/transformers_provider.py` - Token counting, stats tracking, constants
-- `app/utils/constants.py` - Added new constants
-- `app/middleware.py` - Added `/v1/stats` to public paths
-- `open-finance-pydanticAI/app/utils.py` - Fixed duplicate regex
-
----
-
-## 🧪 Testing Recommendations
-
-1. **Health Endpoint:**
-   - Test when model is loading
-   - Test when model is ready
-   - Verify `model_ready` field
-
-2. **Rate Limiting:**
-   - Send 31 requests in 1 minute (should get 429 on 31st)
-   - Verify rate limit headers
-   - Test different IP addresses
-
-3. **Statistics:**
-   - Make several requests
-   - Check `/v1/stats` endpoint
-   - Verify token counts match request usage
-
-4. **Error Handling:**
-   - Test with invalid inputs (should get sanitized errors)
-   - Test internal errors (should not expose details)
-
----
-
-## 🚀 Deployment Notes
-
-1. **Rate Limiting:** Currently in-memory, resets on server restart. For production with multiple servers, consider Redis-based rate limiting.
-
-2. **Statistics:** Currently in-memory, resets on server restart. For production, consider persisting to database.
-
-3. **Constants:** All rate limits and timeouts are configurable via `constants.py`.
-
----
-
-## 📈 Performance Impact
-
-- **Rate Limiting:** Minimal overhead (~1ms per request)
-- **Statistics Tracking:** Minimal overhead (~0.5ms per request)
-- **Token Counting:** Slightly more accurate, negligible performance impact
-
----
-
-## ✅ All Critical Issues Resolved
-
-- ✅ Model readiness check in health endpoint
-- ✅ Error message sanitization
-- ✅ Magic numbers extracted to constants
-- ✅ Duplicate regex fixed
-- ✅ Rate limiting added
-- ✅ Token statistics tracking added
-- ✅ Improved token counting accuracy
-
----
-
-**Status:** All critical issues from code review have been addressed. The codebase is now more secure, maintainable, and provides better observability.
-

CLEANUP_PLAN.md

@@ -1,155 +0,0 @@
-# Code Cleanup Plan
-
-## Overview
-This document outlines the cleanup strategy for the simple-llm-pro-finance project to remove obsolete files and improve code organization.
-
-## Files to Remove
-
-### 1. Obsolete Test Scripts (Root Directory)
-**Reason:** All functional tests have been moved to `tests/` directory. These are one-off debugging scripts.
-
-- `analyze_performance.py` - Performance analysis done, results in FINAL_TEST_REPORT.md
-- `debug_chat_template.py` - Debug script, no longer needed
-- `final_clean_test.py` - One-off test
-- `investigate_french_consistency.py` - Investigation complete
-- `quiz_finance_francais.py` - Test script (also in git staging)
-- `test_advanced_finance.py` - Moved to tests/
-- `test_all_fixes.py` - One-off validation
-- `test_debug_endpoint.sh` - Shell test script
-- `test_finance_final.py` - One-off test
-- `test_finance_improved.py` - One-off test
-- `test_finance_queries.py` - One-off test
-- `test_french_direct.py` - One-off test
-- `test_french_final_check.py` - One-off test
-- `test_french_simple.sh` - Shell test script
-- `test_french_strategies.py` - One-off test
-- `test_generation_fix.sh` - Shell test script
-- `test_memory_stress.py` - Moved to tests/
-- `test_quick_french.py` - One-off test
-- `test_service.py` - One-off test
-- `test_system_prompt.py` - One-off test
-- `test_tokenizer_debug.py` - Debug script
-- `test_truncation_issue.py` - One-off test
-
-**Total:** 21 test files
-
-### 2. Obsolete Documentation Files
-**Reason:** Superseded by comprehensive final reports.
-
-- `STATUS.md` - Historical status, superseded by FINAL_STATUS.md
-- `FIXES_SUMMARY.md` - Historical, covered in FINAL_TEST_REPORT.md
-- `PERFORMANCE_REPORT.md` - Covered in FINAL_TEST_REPORT.md
-- `memory_test_results.txt` - Old test results
-- `test_results.txt` - Old test results
-
-**Total:** 5 documentation files
-
-### 3. Empty/Debug Code Directories
-**Reason:** Unused or debug-only code.
-
-- `app/utils/` - Empty directory (only __pycache__)
-- `app/routers/debug.py` - Debug endpoint not needed in production
-
-**Total:** 1 directory, 1 file
-
-## Files to Keep
-
-### Core Application
-- `app/` directory (except items listed for removal)
-  - `main.py` - FastAPI application
-  - `config.py` - Configuration
-  - `middleware.py` - API key authentication
-  - `models/openai.py` - Pydantic models
-  - `providers/base.py` - Provider protocol
-  - `providers/transformers_provider.py` - Main inference engine
-  - `routers/openai_api.py` - OpenAI-compatible API
-  - `services/chat_service.py` - Chat service wrapper
-
-### Tests
-- `tests/` directory - Proper pytest structure
-  - `conftest.py`
-  - `test_config.py`
-  - `test_middleware.py`
-  - `test_openai_models.py`
-  - `test_openai_routes.py`
-  - `test_providers.py`
-  - `performance/` - Performance benchmarks
-
-### Documentation
-- `README.md` - Main documentation (needs cleanup)
-- `FINAL_STATUS.md` - Final deployment status
-- `FINAL_TEST_REPORT.md` - Comprehensive test results
-- `LICENSE` - MIT license
-
-### Configuration & Deployment
-- `Dockerfile` - Docker build configuration
-- `requirements.txt` - Production dependencies
-- `requirements-dev.txt` - Development dependencies
-
-### Scripts
-- `scripts/validate_hf_readme.py` - Useful validation utility
-- `scripts/README.md` - Scripts documentation
-
-## Refactoring Needed
-
-### 1. Remove Debug Router from Production
-**File:** `app/main.py`
-**Change:** Remove debug router import and mount
-```python
-# Remove this line
-app.include_router(debug.router, prefix="/v1")
-```
-
-### 2. Clean Up README.md
-**File:** `README.md`
-**Changes:**
-- Remove outdated test coverage stats (91% reference)
-- Update to reflect current stable state
-- Simplify configuration section
-- Remove references to obsolete features
-
-### 3. Remove Empty Utils Directory
-**Directory:** `app/utils/`
-**Action:** Delete the entire directory as it's unused
-
-## Impact Assessment
-
-### Breaking Changes
-**None** - All removed files are development/debugging artifacts.
-
-### Non-Breaking Changes
-- Removing debug endpoint (`/v1/debug/prompt`) - Not documented in README
-- Cleaner project structure
-- Reduced repository size
-
-### Benefits
-- **Clarity:** Easier to understand project structure
-- **Maintenance:** Fewer files to maintain
-- **Size:** Reduced repo size
-- **Professionalism:** Clean, production-ready codebase
-
-## Execution Plan
-
-1. ✅ Create backup branch
-2. ✅ Remove obsolete test files
-3. ✅ Remove obsolete documentation
-4. ✅ Remove debug code
-5. ✅ Update README.md
-6. ✅ Run tests to verify nothing broke
-7. ✅ Commit and push changes
-
-## Success Criteria
-
-- ✅ All tests in `tests/` directory still pass
-- ✅ Application still starts and serves requests
-- ✅ README.md is accurate and up-to-date
-- ✅ No broken imports or references
-- ✅ Git history preserved (files deleted, not rewritten)
-
-## Rollback Plan
-
-If issues arise:
-1. Git checkout the cleanup branch: `git checkout pre-cleanup-backup`
-2. Review what was removed
-3. Restore only necessary files
-

CLEANUP_SUMMARY.md

@@ -1,190 +0,0 @@
-# Cleanup Summary - November 2, 2025
-
-## Overview
-Comprehensive codebase cleanup to remove obsolete test scripts, redundant documentation, and debug code from the project.
-
-## Files Removed
-
-### Test Scripts (21 files)
-All one-off debugging and validation scripts have been removed. Proper tests remain in `tests/` directory.
-
-✅ Removed:
-- `analyze_performance.py`
-- `debug_chat_template.py`
-- `final_clean_test.py`
-- `investigate_french_consistency.py`
-- `quiz_finance_francais.py`
-- `test_advanced_finance.py`
-- `test_all_fixes.py`
-- `test_debug_endpoint.sh`
-- `test_finance_final.py`
-- `test_finance_improved.py`
-- `test_finance_queries.py`
-- `test_french_direct.py`
-- `test_french_final_check.py`
-- `test_french_simple.sh`
-- `test_french_strategies.py`
-- `test_generation_fix.sh`
-- `test_memory_stress.py`
-- `test_quick_french.py`
-- `test_service.py`
-- `test_system_prompt.py`
-- `test_tokenizer_debug.py`
-- `test_truncation_issue.py`
-
-### Documentation Files (5 files)
-Historical documentation superseded by comprehensive final reports.
-
-✅ Removed:
-- `STATUS.md` (superseded by FINAL_STATUS.md)
-- `FIXES_SUMMARY.md` (covered in FINAL_TEST_REPORT.md)
-- `PERFORMANCE_REPORT.md` (covered in FINAL_TEST_REPORT.md)
-- `memory_test_results.txt` (old test results)
-- `test_results.txt` (old test results)
-
-### Code Files (2 items)
-Debug code not needed in production.
-
-✅ Removed:
-- `app/routers/debug.py` - Debug endpoint for prompt inspection
-- `app/utils/` - Empty directory
-
-## Code Changes
-
-### Modified: `app/main.py`
-**Before:**
-```python
-from app.routers import openai_api, debug
-...
-app.include_router(debug.router, prefix="/v1")
-```
-
-**After:**
-```python
-from app.routers import openai_api
-...
-# Debug router removed
-```
-
-### Modified: `README.md`
-Updated to reflect:
-- Current stable state (production-ready)
-- Accurate feature list
-- Better API examples with realistic max_tokens
-- Chain-of-thought reasoning explanation
-- Language support details
-- Removed outdated test coverage stats
-- Added technical specifications section
-
-## Project Structure (After Cleanup)
-
-```
-simple-llm-pro-finance/
-├── app/                          # Core application
-│   ├── config.py                 # Configuration
-│   ├── main.py                   # FastAPI app
-│   ├── middleware.py             # API key auth
-│   ├── models/
-│   │   └── openai.py            # Pydantic models
-│   ├── providers/
-│   │   ├── base.py              # Provider protocol
-│   │   └── transformers_provider.py  # Main inference engine
-│   ├── routers/
-│   │   └── openai_api.py        # OpenAI-compatible API
-│   └── services/
-│       └── chat_service.py      # Chat service wrapper
-├── tests/                        # Proper test suite
-│   ├── conftest.py
-│   ├── test_*.py                # Unit tests
-│   └── performance/             # Performance benchmarks
-├── scripts/                      # Utility scripts
-│   └── validate_hf_readme.py    # README validator
-├── Dockerfile                    # Docker build config
-├── requirements.txt              # Production dependencies
-├── requirements-dev.txt          # Development dependencies
-├── README.md                     # Main documentation
-├── FINAL_STATUS.md              # Deployment status
-├── FINAL_TEST_REPORT.md         # Test results & metrics
-├── CLEANUP_PLAN.md              # This cleanup plan
-└── LICENSE                       # MIT license
-```
-
-## Impact Assessment
-
-### Breaking Changes
-**None** - All removed files were development artifacts.
-
-### Removed Endpoints
-- `/v1/debug/prompt` - Debug endpoint (never documented in README)
-
-### Benefits
-- ✅ **Cleaner structure** - 28 fewer files in root directory
-- ✅ **Better organization** - Clear separation of concerns
-- ✅ **Easier navigation** - No clutter from obsolete scripts
-- ✅ **Professional appearance** - Production-ready codebase
-- ✅ **Reduced confusion** - No outdated documentation
-- ✅ **Smaller repo size** - Faster clones and deployments
-
-## Verification
-
-### Syntax Validation
-✅ All Python files compile successfully:
-- `app/main.py` ✓
-- `app/routers/openai_api.py` ✓
-- `app/services/chat_service.py` ✓
-
-### Import Structure
-✅ No broken imports detected
-✅ All module dependencies satisfied
-
-### Test Suite
-✅ Tests remain in `tests/` directory
-✅ Proper pytest structure maintained
-✅ Performance benchmarks preserved
-
-## Git Status
-
-### Staged Changes (Existing)
-- `app/providers/transformers_provider.py` (previous work)
-- `quiz_finance_francais.py` (previous work)
-
-### Unstaged Changes (This Cleanup)
-- Modified: `app/main.py` (removed debug router)
-- Modified: `README.md` (updated documentation)
-- Deleted: 26 obsolete files
-- Added: `CLEANUP_PLAN.md` (this document)
-
-## Backup
-✅ Backup branch created: `pre-cleanup-backup`
-
-To restore if needed:
-```bash
-git checkout pre-cleanup-backup
-```
-
-## Next Steps
-
-1. ✅ Review changes
-2. ⏳ Stage cleanup changes: `git add -A`
-3. ⏳ Commit: `git commit -m "Clean up: Remove obsolete test scripts and documentation"`
-4. ⏳ Optional: Squash with staged changes
-5. ⏳ Push to repository
-
-## Success Criteria
-
-- ✅ All obsolete files removed
-- ✅ Code syntax valid
-- ✅ No broken imports
-- ✅ README updated and accurate
-- ✅ Backup created
-- ✅ Professional project structure
-
-## Summary
-
-**Removed:** 28 files (21 test scripts, 5 docs, 2 code files)  
-**Modified:** 2 files (main.py, README.md)  
-**Added:** 2 files (CLEANUP_PLAN.md, CLEANUP_SUMMARY.md)  
-**Net Change:** -24 files
-
-The codebase is now clean, well-organized, and production-ready! 🎉
-

CODE_REVIEW_SUMMARY.md

@@ -1,119 +0,0 @@
-# Code Review and Cleanup Summary
-
-**Date:** November 2, 2025  
-**Reviewer:** AI Assistant  
-**Status:** Complete
-
-## Executive Summary
-
-Comprehensive codebase cleanup removing 28 obsolete files and refactoring documentation to be professional and concise.
-
-## Changes Made
-
-### Files Removed: 28
-
-**Test Scripts (21 files):**
-- All one-off test/debug scripts moved or removed
-- Proper tests retained in `tests/` directory
-
-**Documentation (5 files):**
-- Obsolete status reports superseded by final documentation
-- Old test result files removed
-
-**Code (2 items):**
-- Debug router removed from production code
-- Empty utils directory removed
-
-### Files Modified: 2
-
-**app/main.py:**
-- Removed debug router import and mount
-- Cleaned up for production deployment
-
-**README.md:**
-- Removed all emojis from section headers
-- Eliminated redundant self-congratulatory content
-- Condensed from 189 to 139 lines
-- Made professional and concise
-- Removed "Features" checklist section
-- Streamlined technical specifications
-- Removed unnecessary "Contributing" section
-
-### Files Added: 3
-
-- `CLEANUP_PLAN.md` - Detailed cleanup strategy
-- `CLEANUP_SUMMARY.md` - Execution summary
-- `CODE_REVIEW_SUMMARY.md` - This document
-
-## Project Structure (After Cleanup)
-
-```
-simple-llm-pro-finance/
-├── app/                    # Application code
-│   ├── config.py
-│   ├── main.py
-│   ├── middleware.py
-│   ├── models/
-│   ├── providers/
-│   ├── routers/
-│   └── services/
-├── tests/                  # Test suite
-├── scripts/                # Utilities
-├── Dockerfile
-├── requirements.txt
-├── requirements-dev.txt
-├── README.md              # Clean, professional docs
-├── FINAL_STATUS.md
-├── FINAL_TEST_REPORT.md
-└── LICENSE
-```
-
-## Code Quality Improvements
-
-**Before:**
-- 50+ files in repository
-- Multiple redundant documentation files
-- Debug endpoints in production code
-- Verbose, emoji-heavy documentation
-- Test scripts scattered in root directory
-
-**After:**
-- 26 essential files
-- Single source of truth for documentation
-- Production-ready code only
-- Professional, concise documentation
-- Organized test directory structure
-
-## Verification
-
-- Python syntax validation: PASSED
-- Import structure: VALID
-- No broken references: CONFIRMED
-- Backup created: `pre-cleanup-backup` branch
-
-## Impact
-
-**Breaking Changes:** None  
-**Removed Endpoints:** `/v1/debug/prompt` (undocumented)  
-**Repository Size:** Reduced by ~24 files  
-**Maintainability:** Significantly improved
-
-## Recommendations
-
-### Immediate
-1. Review and approve changes
-2. Stage all changes: `git add -A`
-3. Commit with message: "refactor: Clean up codebase - remove obsolete files and improve documentation"
-4. Push to repository
-
-### Future Considerations
-1. Consider removing `CLEANUP_PLAN.md` and `CLEANUP_SUMMARY.md` after merge
-2. Update `.gitignore` to prevent future test script accumulation
-3. Establish guidelines for temporary debugging files
-
-## Conclusion
-
-The codebase is now clean, professional, and production-ready. All obsolete development artifacts have been removed, documentation is concise and accurate, and the project structure is well-organized.
-
-**Net Result:** -24 files, cleaner code, better documentation.
-

DEPLOYMENT_READY.md

@@ -1,152 +0,0 @@
-# ✅ Deployment Ready - All Critical Issues Fixed
-
-## Summary
-
-All critical issues from the code review have been fixed and new features have been added. The codebase is ready for deployment.
-
-## ✅ Completed Tasks
-
-### Critical Issues Fixed
-- [x] **Model Readiness Check** - Health endpoint now verifies model status
-- [x] **Error Sanitization** - Internal errors no longer expose sensitive details
-- [x] **Magic Numbers** - All extracted to `constants.py`
-- [x] **Duplicate Regex** - Fixed in `open-finance-pydanticAI/app/utils.py`
-
-### New Features Added
-- [x] **Rate Limiting** - Simple in-memory limiter (30/min, 500/hour)
-- [x] **Statistics Tracking** - Comprehensive token and request statistics
-- [x] **Stats Endpoint** - `/v1/stats` for monitoring usage
-- [x] **Improved Token Counting** - More accurate token tracking
-
-### Tests
-- [x] **Middleware Tests** - All 5 tests passing ✅
-- [x] **Import Issues** - Fixed circular import in middleware package
-- [x] **Test Scripts** - Created deployment test scripts
-
-## 📁 Files Changed
-
-### New Files
-- `app/middleware/rate_limit.py` - Rate limiting middleware
-- `app/middleware/__init__.py` - Middleware package exports
-- `app/utils/stats.py` - Statistics tracking module
-- `test_new_features.py` - Python test script
-- `test_deployment.sh` - Bash deployment test script
-- `DEPLOYMENT_TEST_GUIDE.md` - Testing documentation
-- `CHANGES_SUMMARY.md` - Detailed change log
-
-### Modified Files
-- `app/main.py` - Health check, stats endpoint, middleware setup
-- `app/routers/openai_api.py` - Error sanitization
-- `app/providers/transformers_provider.py` - Stats tracking, token counting
-- `app/utils/constants.py` - New constants added
-- `app/middleware.py` - Added `/v1/stats` to public paths
-- `open-finance-pydanticAI/app/utils.py` - Fixed duplicate regex
-
-## 🚀 Ready to Deploy
-
-### Pre-Deployment Checklist
-- [x] All critical issues fixed
-- [x] Tests passing
-- [x] No linting errors
-- [x] Documentation updated
-- [x] Test scripts created
-
-### Deployment Steps
-
-1. **Review Changes:**
-   ```bash
-   git status
-   git diff
-   ```
-
-2. **Run Tests Locally (if possible):**
-   ```bash
-   # Middleware tests (no model required)
-   pytest tests/test_middleware.py -v
-   
-   # Or use deployment test script
-   ./test_deployment.sh
-   ```
-
-3. **Commit and Push:**
-   ```bash
-   git add .
-   git commit -m "feat: Add rate limiting, stats tracking, and fix critical issues
-
-   - Add model readiness check to health endpoint
-   - Sanitize error messages to prevent information leakage
-   - Extract magic numbers to constants
-   - Fix duplicate regex in utils
-   - Add rate limiting (30/min, 500/hour)
-   - Add comprehensive statistics tracking
-   - Add /v1/stats endpoint
-   - Improve token counting accuracy"
-   
-   git push origin main
-   ```
-
-4. **Verify Deployment:**
-   - Check Hugging Face Spaces logs
-   - Test health endpoint: `curl https://your-space.hf.space/health`
-   - Test stats endpoint: `curl https://your-space.hf.space/v1/stats`
-   - Make a test request and verify stats update
-
-## 📊 New Endpoints
-
-### GET /health
-Returns health status with model readiness:
-```json
-{
-  "status": "healthy",
-  "service": "LLM Pro Finance API",
-  "model_ready": true
-}
-```
-
-### GET /v1/stats
-Returns comprehensive usage statistics:
-```json
-{
-  "uptime_seconds": 3600,
-  "total_requests": 50,
-  "total_tokens": 20000,
-  "average_total_tokens": 400.0,
-  "requests_per_hour": 50.0,
-  "tokens_per_hour": 20000.0,
-  "requests_by_model": {...},
-  "tokens_by_model": {...},
-  "finish_reasons": {...}
-}
-```
-
-## 🔒 Security Improvements
-
-- Error messages sanitized (no internal details leaked)
-- Rate limiting prevents abuse
-- Input validation improved
-
-## 📈 Monitoring
-
-After deployment, monitor:
-- Health endpoint for model status
-- Stats endpoint for usage patterns
-- Rate limiting effectiveness
-- Error rates and types
-
-## 🎯 Next Steps
-
-1. Deploy to Hugging Face Spaces
-2. Run deployment tests
-3. Monitor logs and metrics
-4. Gather user feedback
-5. Consider additional improvements:
-   - Redis-based rate limiting for multi-server
-   - Persistent statistics storage
-   - More detailed monitoring
-
----
-
-**Status:** ✅ Ready for Deployment
-**Date:** 2025-01-30
-**All Tests:** Passing ✅
-

DEPLOYMENT_TEST_GUIDE.md

@@ -1,228 +0,0 @@
-# Deployment and Testing Guide
-
-## Quick Test Summary
-
-All critical issues have been fixed and new features added. Here's how to test them:
-
-## ✅ Changes Made
-
-1. **Health Endpoint** - Now includes `model_ready` status
-2. **Error Sanitization** - Internal errors no longer leak details
-3. **Rate Limiting** - 30 req/min, 500 req/hour (demo-friendly)
-4. **Statistics Tracking** - New `/v1/stats` endpoint
-5. **Improved Token Counting** - More accurate token tracking
-6. **Constants Extracted** - All magic numbers moved to constants
-
-## 🧪 Testing Options
-
-### Option 1: Quick Deployment Test (No Model Required)
-
-```bash
-# Start server (if not already running)
-uvicorn app.main:app --host 0.0.0.0 --port 8080
-
-# Run deployment test script
-./test_deployment.sh
-
-# Or test against deployed instance
-export API_URL=https://your-space.hf.space
-./test_deployment.sh
-```
-
-### Option 2: Python Test Script
-
-```bash
-# Start server first
-uvicorn app.main:app --host 0.0.0.0 --port 8080
-
-# Run test script
-python test_new_features.py
-```
-
-### Option 3: Manual Testing
-
-#### 1. Test Health Endpoint
-```bash
-curl http://localhost:8080/health
-```
-
-**Expected Response:**
-```json
-{
-  "status": "healthy" or "initializing",
-  "service": "LLM Pro Finance API",
-  "model_ready": true or false
-}
-```
-
-#### 2. Test Stats Endpoint
-```bash
-curl http://localhost:8080/v1/stats
-```
-
-**Expected Response:**
-```json
-{
-  "uptime_seconds": 3600,
-  "total_requests": 0,
-  "total_tokens": 0,
-  "average_total_tokens": 0.0,
-  "requests_per_hour": 0.0,
-  "tokens_per_hour": 0.0,
-  ...
-}
-```
-
-#### 3. Test Rate Limiting Headers
-```bash
-curl -I http://localhost:8080/v1/models
-```
-
-**Expected Headers:**
-```
-X-RateLimit-Limit-Minute: 30
-X-RateLimit-Limit-Hour: 500
-X-RateLimit-Remaining-Minute: 29
-X-RateLimit-Remaining-Hour: 499
-```
-
-#### 4. Test Error Sanitization
-```bash
-curl -X POST http://localhost:8080/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -d '{"model":"test","messages":[]}'
-```
-
-**Expected:** 400 error with clear message, no internal details
-
-#### 5. Test Rate Limiting (Trigger 429)
-```bash
-# Make 31 requests quickly
-for i in {1..31}; do
-  curl -s http://localhost:8080/v1/models > /dev/null
-done
-```
-
-**Expected:** 31st request returns 429 with `Retry-After` header
-
-## 🚀 Deployment to Hugging Face Spaces
-
-### Automatic Deployment
-If using Hugging Face Spaces, push to the repository and it will auto-deploy:
-
-```bash
-git add .
-git commit -m "feat: Add rate limiting, stats tracking, and fix critical issues"
-git push origin main
-```
-
-### Manual Verification After Deployment
-
-1. **Check Health:**
-   ```bash
-   curl https://your-username-open-finance-llm-8b.hf.space/health
-   ```
-
-2. **Check Stats:**
-   ```bash
-   curl https://your-username-open-finance-llm-8b.hf.space/v1/stats
-   ```
-
-3. **Make a Test Request:**
-   ```bash
-   curl -X POST https://your-username-open-finance-llm-8b.hf.space/v1/chat/completions \
-     -H "Content-Type: application/json" \
-     -d '{
-       "model": "DragonLLM/qwen3-8b-fin-v1.0",
-       "messages": [{"role": "user", "content": "What is compound interest?"}],
-       "max_tokens": 500
-     }'
-   ```
-
-4. **Check Stats Again:**
-   ```bash
-   curl https://your-username-open-finance-llm-8b.hf.space/v1/stats
-   ```
-   Should show 1 request and token counts.
-
-## 📊 What to Verify
-
-### ✅ Health Endpoint
-- [ ] Returns `model_ready` field
-- [ ] Status is "healthy" when model loaded, "initializing" otherwise
-
-### ✅ Stats Endpoint
-- [ ] Returns comprehensive statistics
-- [ ] Token counts increment after requests
-- [ ] Request counts increment correctly
-- [ ] Averages calculated correctly
-
-### ✅ Rate Limiting
-- [ ] Headers present in responses
-- [ ] 429 returned when limit exceeded
-- [ ] `Retry-After` header present on 429
-- [ ] Limits reset after time window
-
-### ✅ Error Handling
-- [ ] Validation errors return 400 with clear messages
-- [ ] Internal errors return 500 with sanitized messages
-- [ ] No stack traces or file paths in error responses
-
-### ✅ Token Counting
-- [ ] Token counts in responses match stats
-- [ ] Both streaming and non-streaming tracked
-- [ ] Token counts are reasonable (not 0 or extremely high)
-
-## 🐛 Troubleshooting
-
-### Import Errors
-If you see import errors, ensure:
-- All dependencies installed: `pip install -r requirements.txt`
-- Virtual environment activated
-- Python path includes project root
-
-### Rate Limiting Not Working
-- Check middleware is registered in `app/main.py`
-- Verify rate limit constants in `app/utils/constants.py`
-- Check logs for middleware execution
-
-### Stats Not Updating
-- Ensure stats tracker is imported in provider
-- Check that requests are being recorded
-- Verify stats endpoint is accessible (public path)
-
-### Health Check Shows "initializing"
-- Model may still be loading (check logs)
-- Model initialization may have failed (check logs)
-- Wait a few minutes and check again
-
-## 📝 Test Results Template
-
-After testing, document results:
-
-```
-Date: [DATE]
-Environment: [Local/Docker/HF Space]
-Model Status: [Loaded/Initializing/Failed]
-
-Health Endpoint: ✅/❌
-Stats Endpoint: ✅/❌
-Rate Limiting: ✅/❌
-Error Handling: ✅/❌
-Token Counting: ✅/❌
-
-Notes:
-- [Any issues found]
-- [Performance observations]
-- [Recommendations]
-```
-
-## 🎯 Next Steps
-
-1. Run deployment tests
-2. Verify all endpoints work
-3. Test rate limiting behavior
-4. Monitor stats endpoint
-5. Deploy to production
-6. Monitor logs for any issues
-

FINAL_STATUS.md

@@ -1,129 +0,0 @@
-# Final Status Report
-
-## Issues Investigated
-
-### 1. ✅ FIXED: Docker Caching / vLLM → Transformers Migration
-**Status:** RESOLVED
-- Renamed `vllm.py` → `transformers_provider.py`
-- Force-pushed to `main` branch (Space was using `main`, not `master`)
-- Added cache-busting in Dockerfile
-- **Result:** Space now runs Transformers backend
-
-### 2. ✅ FIXED: CUDA Out of Memory Errors
-**Status:** RESOLVED  
-- Added thread-safe initialization with `_init_lock`
-- Proper GPU memory cleanup with `torch.cuda.empty_cache()`
-- Added `max_memory={0: "20GiB"}` limit during model load
-- Added `PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True`
-- Memory cleanup in `finally` blocks
-- **Result:** No more OOM during initialization, 5/5 sequential requests succeeded
-
-### 3. ⚠️  PARTIAL: French Language Support
-**Status:** WORKING BUT INCONSISTENT
-
-**What we discovered:**
-- ✅ System prompts ARE being included in the prompt correctly
-  - Verified with debug endpoint: `<|im_start|>system\nRéponds EN FRANÇAIS<|im_end|>`
-- ✅ Chat template is working correctly (custom `chat_template.jinja` loaded)
-- ✅ Model CAN produce French answers: "Une obligation est un titre de dette émis par..."
-- ❌ Model does NOT always follow system prompts
-- ✅ Reasoning (`<think>` tags) is in English (this is normal for Qwen3 architecture)
-
-**Test results:**
-- Question: "Qu'est-ce qu'une obligation?"  
-  Answer: "Une obligation est un titre de dette émis par des États ou des entreprises..." ✅ French
-  
-- Question: "Qu'est-ce qu'une SICAV?"  
-  Answer: "Une **SICAV** (Société d'Investissement à Capital Variable)..." ✅ French
-
-- Question: "Expliquez le CAC 40"  
-  Answer: "Le **CAC 40** est un indice boursier français qui regroupe..." ✅ French
-
-**Conclusion:** The model DOES respond in French when French is detected. The automatic French detection + system prompt is working.
-
-### 4. ⚠️  IN PROGRESS: Response Truncation
-**Status:** IMPROVING
-
-**Issue:** Responses hitting `max_tokens` limit (finish_reason: length)
-
-**Why:** Qwen3 uses `<think>` tags for reasoning:
-- Reasoning: 300-500 tokens  
-- Answer: 400-800 tokens
-- Total needed: 700-1300 tokens
-
-**Changes made:**
-- Increased default `max_tokens`: 500 → 800 → 1200
-- Added proper `finish_reason` detection (was always "stop", now detects "length")
-- Added `early_stopping=False` to prevent mid-sentence cutoffs
-- Removed `min_new_tokens` constraint
-
-**Waiting for:** Space rebuild to deploy `max_tokens=1200` default
-
----
-
-## Current Status Summary
-
-| Issue | Status | Notes |
-|-------|--------|-------|
-| Docker caching | ✅ RESOLVED | Transformers backend deployed |
-| OOM errors | ✅ RESOLVED | Memory cleanup working, 5/5 requests succeeded |
-| System prompts | ✅ WORKING | Verified in prompt, model partially follows |
-| French answers | ✅ WORKING | Model responds in French when detected |
-| French reasoning | ⚠️  BY DESIGN | Qwen3 uses English for `<think>` (normal) |
-| Truncation | 🔄 IN PROGRESS | Increased max_tokens to 1200, waiting for deployment |
-
----
-
-## Key Technical Discoveries
-
-### Chat Template
-The model has a custom Qwen3 chat template (`chat_template.jinja`) that:
-- Uses `<|im_start|>` and `<|im_end|>` tokens
-- Supports system/user/assistant roles
-- Handles `<think>` tags for reasoning
-- **Is being applied correctly** ✅
-
-### System Prompt Handling
-- System prompts ARE in the generated prompt ✅
-- Model follows them **inconsistently** (depends on prompt strength)
-- Better strategy: French instruction in user message + system prompt
-
-### French Language Capability
-- Model **was fine-tuned** on French finance data (LinguaCustodia base)
-- Can produce high-quality French financial answers
-- Reasoning is in English (Qwen3 architecture design)
-- Auto-detection + system prompt is effective
-
----
-
-## Recommendations
-
-### For French Responses
-Current implementation is good:
-1. Auto-detect French from accented characters and patterns ✅
-2. Add French system prompt automatically ✅
-3. Users can also add explicit "Répondez en français" in their question
-
-### For Complete Answers
-- Default `max_tokens=1200` should handle most cases
-- Users can request higher for complex questions
-- Clients should check `finish_reason: "length"` for truncation
-
-### For Production
-- Current setup works well for single-user scenarios
-- Consider vLLM for multi-user / high throughput
-- L4 GPU provides ~15 tokens/s (typical for 8B models)
-
----
-
-## Next Test
-Once Space rebuilds with `max_tokens=1200`, run final verification:
-```bash
-python test_all_fixes.py
-```
-
-Expected results:
-- ✅ No OOM errors
-- ✅ French answers working
-- ✅ Minimal truncation (finish_reason: stop)
-

FINAL_TEST_REPORT.md

@@ -1,261 +0,0 @@
-# Final Test Report: Finance LLM Deployment
-
-**Date:** November 2, 2025  
-**Model:** DragonLLM/qwen3-8b-fin-v1.0  
-**Backend:** Transformers (PyTorch)  
-**Hardware:** NVIDIA L4 GPU (24GB VRAM)  
-**Space:** https://huggingface.co/spaces/jeanbaptdzd/open-finance-llm-8b
-
----
-
-## ✅ All Issues Resolved
-
-### 1. Docker Caching Issue - **FIXED**
-**Problem:** Space was using cached Docker image with old vLLM code  
-**Root Cause:**
-- Branch mismatch (pushing to `master`, Space building from `main`)
-- Docker layer caching reused old code
-- File `vllm.py` hadn't changed → cache persisted
-
-**Solution:**
-- ✅ Renamed `vllm.py` → `transformers_provider.py` (invalidates cache)
-- ✅ Force-pushed correct code to `main` branch
-- ✅ Added cache-busting and verification in Dockerfile
-
-**Result:** Space now runs Transformers backend successfully  
-```json
-{"backend": "Transformers"}  // Previously "vLLM"
-```
-
----
-
-### 2. CUDA Out of Memory (OOM) - **FIXED**
-**Problem:** Space crashed with CUDA OOM errors after initial deployment  
-**Root Cause:** No GPU memory cleanup between inference requests, causing memory accumulation
-
-**Solution:**
-- ✅ Added `torch.cuda.empty_cache()` after each inference
-- ✅ Added `gc.collect()` for Python garbage collection
-- ✅ Proper cleanup in both streaming and non-streaming code paths
-- ✅ Moved token counting before cleanup to avoid variable deletion errors
-
-**Result:** Space runs stably with no memory errors  
-```python
-# After each inference:
-torch.cuda.empty_cache()
-gc.collect()
-```
-
----
-
-### 3. Truncated Responses - **FIXED**
-**Problem:** Responses cut off mid-sentence  
-**Root Cause:** Qwen3 uses `<think>` tags for reasoning, which consume 40-60% of max_tokens
-
-**Solution:**
-- ✅ Increased max_tokens: 150-200 → 300-600 (based on complexity)
-- ✅ Added `min_new_tokens` to ensure minimum generation
-- ✅ Fixed `min_new_tokens` formula: was `max_tokens // 2`, now `max_tokens // 10`
-- ✅ Added `repetition_penalty=1.05` to prevent loops
-- ✅ Added explicit `eos_token_id` handling
-
-**Result:** All responses complete properly (100% finish_reason=stop)
-
----
-
-### 4. French Language Support - **WORKING AS DESIGNED**
-**Observation:** French questions show English reasoning in `<think>` tags  
-**Finding:** This is intentional in Qwen3 models
-
-**Behavior:**
-```
-User: [Question in French]
-Model: <think>[Reasoning in English]</think>
-       [Answer in French]
-```
-
-**Explanation:**
-- Qwen3 is pretrained to use English for internal reasoning
-- Maintains consistency and quality across languages
-- Final answers are correctly in the requested language
-- This is standard behavior for multilingual reasoning models
-
----
-
-## 📊 Test Results Summary
-
-### English Tests (3/3 Passed - 100%)
-| Test | Category | Tokens | Time | Status |
-|------|----------|--------|------|--------|
-| 1 | Financial Calculations | 300/300 | 20.34s | ✅ |
-| 2 | Risk Management (VaR) | 350/350 | 23.43s | ✅ |
-| 3 | Options Trading | 300/300 | 20.31s | ✅ |
-
-### French Tests (4/4 Passed - 100%)
-| Test | Category | Tokens | Time | Status |
-|------|----------|--------|------|--------|
-| 1 | Calculs Financiers | 300/300 | 20.16s | ✅ |
-| 2 | Gestion des Risques (VaR) | 350/350 | 23.48s | ✅ |
-| 3 | Options (Call/Put) | 300/300 | 20.25s | ✅ |
-| 4 | Termes Français (CAC 40, PEA, etc.) | 400/400 | 27.02s | ✅ |
-
-### Overall Performance
-- **Success Rate:** 7/7 (100%)
-- **Completion Rate:** 7/7 (100% - all finish_reason=stop)
-- **Average Speed:** 14.8 tokens/second
-- **Average Response Time:** 22.0 seconds
-- **Memory Usage:** Stable (no OOM errors)
-
----
-
-## 🚀 Performance Characteristics
-
-### Inference Speed
-- **Tokens/second:** ~14.8 (consistent across all tests)
-- **Short responses (50 tokens):** ~3.6s
-- **Medium responses (300 tokens):** ~20s
-- **Long responses (400 tokens):** ~27s
-
-### Memory Management
-- **GPU:** NVIDIA L4 (24GB VRAM)
-- **Model Size:** Qwen3-8B (8 billion parameters)
-- **Memory Efficiency:** Excellent with cleanup
-- **Concurrent Requests:** Sequential processing (no batching yet)
-
-### Quality
-- **Reasoning:** Shows `<think>` tags with step-by-step reasoning
-- **Finance Knowledge:** Accurate for VaR, options, compound interest, French market terms
-- **Language Support:** English ✅, French ✅ (answers in correct language)
-- **Completeness:** 100% of responses finish naturally (finish_reason=stop)
-
----
-
-## 🔧 Technical Implementation
-
-### Generation Parameters (Optimized)
-```python
-{
-    "max_new_tokens": 300-600,  # Increased for reasoning
-    "min_new_tokens": max(10, max_tokens // 10),  # Fixed formula
-    "temperature": 0.3,
-    "top_p": 1.0,
-    "do_sample": True,
-    "pad_token_id": tokenizer.eos_token_id,
-    "eos_token_id": tokenizer.eos_token_id,
-    "repetition_penalty": 1.05
-}
-```
-
-### Memory Management
-```python
-try:
-    outputs = model.generate(**inputs, **generation_kwargs)
-    # Process outputs
-finally:
-    del inputs, outputs
-    torch.cuda.empty_cache()
-    gc.collect()
-```
-
-### Docker Configuration
-```dockerfile
-# Cache-busting for fresh builds
-ARG CACHE_BUST=20250130_1425
-RUN echo "Build cache bust: ${CACHE_BUST}"
-
-# Code verification
-RUN test -f /app/app/providers/transformers_provider.py && \
-    grep -q "from transformers import" /app/app/providers/transformers_provider.py
-```
-
----
-
-## 📝 Key Learnings
-
-### 1. Docker Layer Caching in HF Spaces
-- File path changes invalidate cache more reliably than content changes
-- Renaming files forces fresh rebuild
-- Add verification steps in Dockerfile to catch caching issues
-
-### 2. GPU Memory Management with PyTorch
-- **Must** call `torch.cuda.empty_cache()` after each inference
-- Python's `gc.collect()` helps but isn't sufficient alone
-- Delete tensors explicitly before cleanup
-- Save required values before cleanup (token counts, etc.)
-
-### 3. Qwen3 Model Characteristics
-- Uses `<think>` tags for chain-of-thought reasoning
-- Reasoning consumes 40-60% of token budget
-- Needs higher max_tokens than expected (300-600 instead of 150-200)
-- Internal reasoning in English even for non-English queries (by design)
-- Produces high-quality finance-specific answers
-
-### 4. Token Budget Considerations
-```
-User prompt: 50 tokens
-<think> reasoning: 150-250 tokens (40-60% of max)
-Actual answer: 100-200 tokens
-Total needed: 300-500 tokens minimum
-```
-
----
-
-## ✅ Production Readiness
-
-### What's Working
-- ✅ Stable inference with no crashes
-- ✅ Good response quality (100% completion rate)
-- ✅ Proper memory management
-- ✅ Multi-language support (English, French)
-- ✅ Finance-specific knowledge accurate
-- ✅ OpenAI API compatibility
-
-### Known Limitations
-- ⚠️ Sequential processing only (no request batching)
-- ⚠️ ~15 tokens/s (typical for 8B models on L4)
-- ⚠️ Reasoning in `<think>` tags always in English
-- ⚠️ Token budget must account for reasoning overhead
-
-### Recommendations for Production
-1. **For higher throughput:** Consider vLLM backend with continuous batching
-2. **For cost optimization:** Current Transformers backend is fine for <10 users
-3. **For faster inference:** Upgrade to L40s or A100 GPU
-4. **For scaling:** Implement request queuing and load balancing
-
----
-
-## 🎯 Next Steps (Optional Improvements)
-
-### Performance Optimization
-- [ ] Implement vLLM backend for 3-5x speedup with batching
-- [ ] Add request queuing for concurrent users
-- [ ] Enable tensor parallelism for multi-GPU setups
-- [ ] Implement KV cache optimization
-
-### User Experience
-- [ ] Add option to hide `<think>` tags in responses
-- [ ] Implement streaming responses (already supported)
-- [ ] Add response time monitoring
-- [ ] Create user dashboard with model stats
-
-### Advanced Features
-- [ ] Fine-tune on additional French finance terminology
-- [ ] Add RAG (Retrieval-Augmented Generation) for current market data
-- [ ] Implement function calling for calculations
-- [ ] Add multi-turn conversation memory
-
----
-
-## 📚 References
-
-- Model: https://huggingface.co/DragonLLM/qwen3-8b-fin-v1.0
-- Space: https://huggingface.co/spaces/jeanbaptdzd/open-finance-llm-8b
-- Backend: Transformers (PyTorch)
-- Hardware: NVIDIA L4 GPU (24GB VRAM)
-
----
-
-**Status:** ✅ **PRODUCTION READY**  
-**Last Updated:** November 2, 2025  
-**Tested by:** Automated test suite (7 comprehensive finance scenarios)
-

README.md

@@ -17,16 +17,26 @@ OpenAI-compatible API powered by DragonLLM/qwen3-8b-fin-v1.0 using Transformers.
 
 This service provides an OpenAI-compatible API for the DragonLLM Qwen3-8B finance-specialized language model. The model supports both English and French financial terminology and includes chain-of-thought reasoning.
 
+## Features
+
+- ✅ **OpenAI-Compatible API** - Drop-in replacement for OpenAI API
+- ✅ **French & English Support** - Automatic language detection
+- ✅ **Rate Limiting** - Built-in protection (30 req/min, 500 req/hour)
+- ✅ **Statistics Tracking** - Token usage and request metrics via `/v1/stats`
+- ✅ **Health Monitoring** - Model readiness status in `/health` endpoint
+- ✅ **Streaming Support** - Real-time response streaming
+- ✅ **PydanticAI Integration** - High-level agent framework included
+
 ## API Endpoints
 
 ### List Models
 ```bash
-curl -X GET "https://your-username-open-finance-llm-8b.hf.space/v1/models"
+curl -X GET "https://jeanbaptdzd-open-finance-llm-8b.hf.space/v1/models"
 ```
 
 ### Chat Completions
 ```bash
-curl -X POST "https://your-username-open-finance-llm-8b.hf.space/v1/chat/completions" \
+curl -X POST "https://jeanbaptdzd-open-finance-llm-8b.hf.space/v1/chat/completions" \
   -H "Content-Type: application/json" \
   -d '{
     "model": "DragonLLM/qwen3-8b-fin-v1.0",
@@ -38,7 +48,7 @@ curl -X POST "https://your-username-open-finance-llm-8b.hf.space/v1/chat/complet
 
 ### Streaming
 ```bash
-curl -X POST "https://your-username-open-finance-llm-8b.hf.space/v1/chat/completions" \
+curl -X POST "https://jeanbaptdzd-open-finance-llm-8b.hf.space/v1/chat/completions" \
   -H "Content-Type: application/json" \
   -d '{
     "model": "DragonLLM/qwen3-8b-fin-v1.0",
@@ -47,11 +57,21 @@ curl -X POST "https://your-username-open-finance-llm-8b.hf.space/v1/chat/complet
   }'
 ```
 
+### Statistics
+```bash
+curl -X GET "https://jeanbaptdzd-open-finance-llm-8b.hf.space/v1/stats"
+```
+
+### Health Check
+```bash
+curl -X GET "https://jeanbaptdzd-open-finance-llm-8b.hf.space/health"
+```
+
 ## Response Format
 
 Responses include chain-of-thought reasoning in `<think>` tags followed by the answer. Reasoning typically consumes 40-60% of tokens.
 
-Recommended `max_tokens`:
+**Recommended `max_tokens`:**
 - Simple queries: 300-400
 - Complex queries: 500-800
 - Detailed analysis: 800-1200
@@ -72,29 +92,50 @@ Recommended `max_tokens`:
 
 Token priority: `HF_TOKEN_LC2` > `HF_TOKEN_LC` > `HF_TOKEN` > `HUGGING_FACE_HUB_TOKEN`
 
-Note: Accept model terms at https://huggingface.co/DragonLLM/qwen3-8b-fin-v1.0 before use.
+**Note:** Accept model terms at https://huggingface.co/DragonLLM/qwen3-8b-fin-v1.0 before use.
 
 ## Integration
 
 ### PydanticAI
+
+The repository includes a PydanticAI integration in `pydanticai_app/`:
+
+```python
+from pydanticai_app.agents import finance_agent
+
+result = await finance_agent.run("Qu'est-ce qu'une obligation?")
+```
+
+Or use the FastAPI server:
+```bash
+uvicorn pydanticai_app.main:app --port 8001
+```
+
+### OpenAI SDK
+
 ```python
-from pydantic_ai import Agent
-from pydantic_ai.models.openai import OpenAIModel
+from openai import OpenAI
 
-model = OpenAIModel(
-    "DragonLLM/qwen3-8b-fin-v1.0",
-    base_url="https://your-username-open-finance-llm-8b.hf.space/v1"
+client = OpenAI(
+    base_url="https://jeanbaptdzd-open-finance-llm-8b.hf.space/v1",
+    api_key="not-needed"
+)
+
+response = client.chat.completions.create(
+    model="DragonLLM/qwen3-8b-fin-v1.0",
+    messages=[{"role": "user", "content": "What is compound interest?"}],
+    max_tokens=500
 )
-agent = Agent(model=model)
 ```
 
 ### DSPy
+
 ```python
 import dspy
 
 lm = dspy.OpenAI(
     model="DragonLLM/qwen3-8b-fin-v1.0",
-    api_base="https://your-username-open-finance-llm-8b.hf.space/v1"
+    api_base="https://jeanbaptdzd-open-finance-llm-8b.hf.space/v1"
 )
 ```
 
@@ -122,21 +163,41 @@ lm = dspy.OpenAI(
 ## Development
 
 ### Local Setup
+
 ```bash
 pip install -r requirements.txt
 uvicorn app.main:app --reload --port 8080
 ```
 
 ### Testing
+
 ```bash
+# Run tests
 pytest -v
-pytest --cov=app tests/
+
+# Test deployment
+./test_deployment.sh
+
+# Test PydanticAI integration
+python test_pydanticai.py
 ```
 
-## Documentation
+## Project Structure
 
-- [FINAL_STATUS.md](FINAL_STATUS.md) - Deployment status
-- [FINAL_TEST_REPORT.md](FINAL_TEST_REPORT.md) - Test results and metrics
+```
+.
+├── app/                    # Main API application
+│   ├── main.py            # FastAPI app
+│   ├── routers/           # API routes
+│   ├── providers/         # Model providers
+│   ├── middleware/       # Rate limiting, auth
+│   └── utils/             # Utilities, stats tracking
+├── pydanticai_app/        # PydanticAI integration
+├── examples/              # Example scripts
+├── docs/                  # Documentation
+├── tests/                 # Test suite
+└── scripts/               # Utility scripts
+```
 
 ## License
 

TEST_CODERABBIT.md

@@ -1,40 +0,0 @@
-# Testing CodeRabbit Integration
-
-## What to do:
-
-1. **Create a branch:**
-   ```bash
-   git checkout -b test-coderabbit-review
-   ```
-
-2. **Commit this test file:**
-   ```bash
-   git add TEST_CODERABBIT.md .github/pull_request_template.md
-   git commit -m "test: Add PR template and test CodeRabbit integration"
-   ```
-
-3. **Push and create PR:**
-   ```bash
-   git push origin test-coderabbit-review
-   ```
-   Then go to GitHub and create a Pull Request from `test-coderabbit-review` to `master`
-
-4. **Watch for CodeRabbit:**
-   - CodeRabbit should automatically comment on your PR
-   - It will review code quality, suggest improvements
-   - Check for CodeRabbit comments in the PR thread
-
-## What CodeRabbit will review:
-- Code quality and best practices
-- Potential bugs or security issues
-- Performance optimizations
-- Documentation completeness
-- Test coverage
-
-## To test more thoroughly:
-After this test, try creating a PR with:
-- A small bug (see if it catches it)
-- Missing error handling
-- Performance issues
-- Security concerns
-

docs/generation_limits.md

@@ -0,0 +1,85 @@
+# Limites de génération - Qwen-3 8B
+
+## Limite théorique maximale
+
+**20 000 tokens** peuvent être générés en sortie (selon les spécifications Qwen-3 8B).
+
+## Limite pratique
+
+La limite pratique dépend de la **fenêtre de contexte disponible**:
+
+```
+max_tokens_generable = fenêtre_contexte - tokens_entrée - marge_sécurité
+```
+
+### Exemples pratiques
+
+| Contexte d'entrée | Fenêtre totale | Max génération | Marge |
+|-------------------|----------------|----------------|-------|
+| 2K tokens | 32K | ~30K tokens | ✅ Large |
+| 10K tokens | 32K | ~22K tokens | ✅ Bonne |
+| 20K tokens | 32K | ~12K tokens | ✅ Suffisant |
+| 30K tokens | 32K | ~2K tokens | ⚠️ Limite |
+| 50K tokens | 128K (YaRN) | ~78K tokens | ✅ Très large |
+
+## Pour notre application
+
+### Configuration actuelle
+- **max_tokens configuré:** 1500 tokens
+- **Typique contexte entrée:** ~100-500 tokens (messages conversation)
+- **Disponible pour génération:** ~30K tokens
+
+### Pourquoi 1500 tokens est suffisant?
+
+1. **Questions simples:** 800-1000 tokens suffisent
+2. **Analyses complexes:** 1500 tokens couvrent raisonnement + réponse
+3. **Messages SWIFT:** 1200-1500 tokens pour format complet
+4. **Marge de sécurité:** Reste bien en dessous de la limite pratique
+
+## Ajuster max_tokens selon les besoins
+
+### Questions simples (max_tokens=800)
+```python
+agent_short = Agent(
+    finance_model,
+    model_settings=ModelSettings(max_output_tokens=800),
+)
+```
+
+### Analyses complexes (max_tokens=2000)
+```python
+agent_long = Agent(
+    finance_model,
+    model_settings=ModelSettings(max_output_tokens=2000),
+)
+```
+
+### Documents très longs (max_tokens=5000)
+```python
+agent_very_long = Agent(
+    finance_model,
+    model_settings=ModelSettings(max_output_tokens=5000),
+)
+# Nécessite que l'entrée soit < 27K tokens
+```
+
+## Recommandations
+
+| Cas d'usage | max_tokens recommandé | Notes |
+|-------------|----------------------|-------|
+| Questions rapides | 800-1000 | Suffisant pour la plupart |
+| Réponses détaillées | 1500-2000 | Inclut raisonnement |
+| Messages SWIFT | 1200-1500 | Format structuré |
+| Analyses longues | 2000-4000 | Si nécessaire |
+| Génération de code/docs | 3000-5000 | Documents complets |
+
+**Note:** Au-delà de 5000 tokens, vérifiez que votre contexte d'entrée n'est pas trop volumineux.
+
+
+
+
+
+
+
+
+

docs/qwen3_specifications.md

@@ -0,0 +1,82 @@
+# Spécifications Qwen-3 8B - Fenêtre de contexte
+
+## Fenêtre de contexte maximale
+
+Le modèle **DragonLLM/qwen3-8b-fin-v1.0** (basé sur Qwen-3 8B) supporte:
+
+### Fenêtre de base
+- **32 768 tokens** (32K tokens)
+- Support natif pour la plupart des cas d'usage
+
+### Fenêtre étendue (avec YaRN)
+- **128 000 tokens** (128K tokens) 
+- Extension via le mécanisme YaRN (Yet another RoPE extensioN)
+- Nécessite une configuration spécifique pour activer
+
+## Composition du contexte
+
+Quand vous envoyez une requête, le contexte total inclut:
+
+```
+Contexte total = Prompt système + Messages conversation + Réponse générée
+```
+
+### Exemples pratiques:
+
+| Type de requête | Prompt + Messages | Réponse max | Total |
+|----------------|-------------------|-------------|-------|
+| Question simple | ~100 tokens | 800 tokens | ~900 tokens |
+| Analyse complexe | ~500 tokens | 1500 tokens | ~2000 tokens |
+| Document long | ~5000 tokens | 2000 tokens | ~7000 tokens |
+| Analyse très longue | ~15000 tokens | 4000 tokens | ~19000 tokens |
+
+**Limite pratique recommandée:** 30 000 tokens pour laisser de la marge.
+
+## Limite de génération (max_tokens)
+
+**Limite théorique maximale:** **20 000 tokens** en sortie
+
+**Limite pratique:** Dépend de la fenêtre de contexte disponible:
+- Si contexte d'entrée = 2K tokens → peut générer jusqu'à ~30K tokens
+- Si contexte d'entrée = 10K tokens → peut générer jusqu'à ~22K tokens  
+- Si contexte d'entrée = 30K tokens → peut générer jusqu'à ~2K tokens
+
+**Formule:** `max_tokens_generable = fenêtre_contexte - tokens_entrée - marge_sécurité`
+
+## Configuration actuelle
+
+Dans notre application PydanticAI:
+- `max_tokens` (génération): **1500 tokens** (configurable)
+- Contexte d'entrée: Illimité jusqu'à ~30K tokens (pour laisser de la marge)
+- Contexte total: Jusqu'à 32K tokens (base) ou 128K (avec YaRN)
+- Limite théorique max: 20K tokens en sortie (mais contrainte par contexte disponible)
+
+## Recommandations
+
+### Pour des requêtes simples:
+```python
+max_tokens = 800-1000  # Suffisant pour la plupart des réponses
+```
+
+### Pour des requêtes complexes (SWIFT, analyses):
+```python
+max_tokens = 1500-2000  # Permet raisonnement + réponse complète
+```
+
+### Pour des documents longs:
+- Utilisez le contexte jusqu'à ~30K tokens pour le prompt
+- Réservez 2-5K tokens pour la réponse
+- Total: jusqu'à 32K tokens (base)
+
+### Activation de YaRN pour contexte étendu:
+Si vous avez besoin de plus de 32K tokens:
+1. Vérifiez que le backend Transformers supporte YaRN
+2. Configurez les paramètres de RoPE scaling
+3. La fenêtre peut être étendue jusqu'à 128K tokens
+
+## Références
+
+- Qwen-3 models: Fenêtre de 32K tokens (base), 128K avec YaRN
+- YaRN: Yet another RoPE extensioN - méthode d'extension de contexte
+- Documentation technique Qwen: https://huggingface.co/Qwen/Qwen2.5
+

docs/reasoning_models.md

@@ -0,0 +1,94 @@
+# Gestion des modèles de raisonnement avec PydanticAI
+
+## Problème: "finish on length"
+
+Quand vous voyez `finish_reason: "length"`, cela signifie que le modèle a atteint la limite de `max_tokens` avant de terminer sa réponse.
+
+## Pourquoi c'est fréquent avec les modèles de raisonnement?
+
+Les modèles comme Qwen3 utilisent des balises `<think>` (ou `<think>`) pour le raisonnement en chaîne:
+
+```
+<think>
+1. L'utilisateur demande un message SWIFT MT103
+2. Je dois identifier les champs requis
+3. Format: :20: référence, :32A: date/devise/montant...
+</think>
+
+Voici le message SWIFT généré:
+:20:NONREF
+:23B:CRED
+...
+```
+
+**Le raisonnement peut consommer 40-60% du budget de tokens!**
+
+## Solution: Augmenter max_tokens
+
+Nous avons configuré `max_tokens=1500` dans `app/config.py` pour permettre:
+- ~600-900 tokens pour le raisonnement (`<think>` tags)
+- ~600-900 tokens pour la réponse finale
+- Total: ~1500 tokens pour des réponses complètes
+
+## Configuration actuelle
+
+```python
+# app/config.py
+max_tokens: int = 1500  # Pour modèles de raisonnement
+
+# app/models.py
+model_settings = ModelSettings(
+    max_output_tokens=settings.max_tokens,
+)
+finance_model = OpenAIModel(
+    ...,
+    model_settings=model_settings,
+)
+```
+
+## Recommandations par type de requête
+
+| Type de requête | max_tokens recommandé |
+|----------------|----------------------|
+| Questions simples | 800-1000 |
+| Génération SWIFT | 1200-1500 |
+| Analyse complexe | 1500-2000 |
+| Extraction structurée | 1000-1200 |
+
+## Comment ajuster pour un agent spécifique?
+
+Vous pouvez créer des agents avec des settings différents:
+
+```python
+from pydantic_ai import ModelSettings, Agent
+
+# Agent pour tâches courtes
+short_agent = Agent(
+    finance_model,
+    model_settings=ModelSettings(max_output_tokens=800),
+    system_prompt="..."
+)
+
+# Agent pour tâches longues (SWIFT, analyses)
+long_agent = Agent(
+    finance_model,
+    model_settings=ModelSettings(max_output_tokens=2000),
+    system_prompt="..."
+)
+```
+
+## Vérifier si la réponse est complète
+
+Notre utilitaire `extract_answer_from_reasoning()` dans `app/utils.py` gère automatiquement:
+- Extraction de la réponse après les balises `<think>`
+- Détection si la réponse est tronquée
+- Nettoyage des balises de raisonnement
+
+
+
+
+
+
+
+
+

examples/README.md

@@ -0,0 +1,121 @@
+# Exemples d'Agentique avec PydanticAI
+
+Ces exemples démontrent différentes capacités agentiques de PydanticAI utilisant le modèle DragonLLM via le Hugging Face Space.
+
+## Installation
+
+```bash
+cd /Users/jeanbapt/open-finance-pydanticAI
+pip install -e ".[dev]"
+```
+
+## Exemples
+
+### Agent 1: Extraction de données structurées
+**Fichier:** `agent_1_structured_data.py`
+
+Démontre l'extraction et la validation de données financières structurées à partir de textes non structurés.
+
+**Fonctionnalités:**
+- Utilisation de `output_type` avec modèles Pydantic
+- Validation automatique des données
+- Extraction d'informations complexes (portfolios, transactions)
+
+**Exécution:**
+```bash
+python examples/agent_1_structured_data.py
+```
+
+### Agent 2: Agent avec outils (Tools)
+**Fichier:** `agent_2_tools.py`
+
+Démontre l'utilisation d'outils Python que l'agent peut appeler pour effectuer des calculs.
+
+**Fonctionnalités:**
+- Définition d'outils Python (fonctions)
+- Appel automatique d'outils par l'agent
+- Combinaison de raisonnement LLM + calculs précis
+
+**Outils disponibles:**
+- `calculer_valeur_future()` - Intérêts composés
+- `calculer_versement_mensuel()` - Prêts immobiliers
+- `calculer_performance_portfolio()` - Performance d'investissements
+
+**Exécution:**
+```bash
+python examples/agent_2_tools.py
+```
+
+### Agent 4: Outils et mémoire
+**Fichier:** `agent_with_tools_and_memory.py`
+
+Démontre l'utilisation combinée d'outils Python et de mémoire (History) pour créer des agents conversationnels intelligents.
+
+**Fonctionnalités:**
+- Outils financiers intégrés (calculs précis)
+- Mémoire conversationnelle (History)
+- Agents qui se souviennent du contexte
+- Conseils personnalisés basés sur l'historique
+
+**Outils disponibles:**
+- `calculer_valeur_future()` - Intérêts composés
+- `calculer_versement_mensuel()` - Prêts immobiliers
+- `calculer_performance_portfolio()` - Performance d'investissements
+- `calculer_ratio_dette()` - Analyse d'endettement
+
+**Exécution:**
+```bash
+python examples/agent_with_tools_and_memory.py
+```
+
+### Agent 5: Stratégies de mémoire
+**Fichier:** `memory_strategies.py`
+
+Démontre différentes stratégies de gestion de mémoire pour optimiser les performances et la persistance.
+
+**Stratégies:**
+1. Mémoire simple (History) - Tout est conservé
+2. Mémoire sélective - Extraction de faits clés
+3. Mémoire structurée - Profil client typé
+4. Mémoire avec résumé - Compression périodique
+5. Mémoire persistante - Sauvegarde/chargement multi-session
+
+**Exécution:**
+```bash
+python examples/memory_strategies.py
+```
+
+### Agent 3: Workflow multi-étapes
+**Fichier:** `agent_3_multi_step.py`
+
+Démontre la création d'un workflow où plusieurs agents spécialisés collaborent.
+
+**Fonctionnalités:**
+- Agents spécialisés (analyse de risque, fiscalité, optimisation)
+- Passage de contexte entre agents
+- Orchestration de workflows complexes
+
+**Agents:**
+- `risk_analyst` - Analyse de risque financier
+- `tax_advisor` - Conseil fiscal français
+- `portfolio_optimizer` - Optimisation de portfolio
+
+**Exécution:**
+```bash
+python examples/agent_3_multi_step.py
+```
+
+## Points clés démontrés
+
+1. **Extraction structurée**: PydanticAI peut extraire et valider des données complexes
+2. **Outils intégrés**: Les agents peuvent appeler des fonctions Python pour des calculs précis
+3. **Multi-agents**: Plusieurs agents peuvent collaborer pour résoudre des problèmes complexes
+4. **Raisonnement**: Le modèle Qwen3 fournit le raisonnement via les balises `<think>`
+
+## Cas d'usage réels
+
+Ces exemples peuvent être adaptés pour:
+- **Analyse de documents financiers**: Extraction automatique de données de contrats, factures
+- **Calculs financiers interactifs**: Assistants qui calculent en temps réel
+- **Conseil financier automatisé**: Workflows d'analyse multi-domaines
+

examples/SWIFT_IMPROVEMENTS.md

@@ -0,0 +1,157 @@
+# Améliorations de l'extraction SWIFT
+
+## Résumé des améliorations
+
+L'extraction de messages SWIFT a été complètement révisée et améliorée avec:
+
+### 1. Parser robuste avec validation Pydantic
+
+**Fichier:** `swift_extractor.py`
+
+- Nouveau module dédié à l'extraction SWIFT avec validation stricte
+- Utilisation de modèles Pydantic pour garantir la cohérence des données
+- Validation automatique des formats (dates, devises, montants, BIC)
+
+### 2. Support complet des champs SWIFT MT103
+
+**Champs gérés:**
+- `:20:` - Référence du transfert
+- `:23B:` - Code instruction (CRED, etc.)
+- `:32A:` - Date de valeur, devise, montant (avec parsing intelligent)
+- `:50K:`, `:50A:`, `:50F:` - Ordre donneur (multi-lignes)
+- `:52A:`, `:52D:` - Banque ordonnateur
+- `:56A:`, `:56D:` - Banque intermédiaire
+- `:57A:`, `:57D:` - Banque bénéficiaire
+- `:59:`, `:59A:` - Bénéficiaire (multi-lignes)
+- `:70:` - Information pour bénéficiaire (multi-lignes)
+- `:71A:` - Frais (OUR/SHA/BEN)
+- `:72:` - Information banque à banque (multi-lignes)
+
+### 3. Gestion des champs multi-lignes
+
+Le parser gère correctement les champs qui s'étendent sur plusieurs lignes:
+- Lire toutes les lignes jusqu'au prochain tag SWIFT
+- Préserver les sauts de ligne dans les adresses et noms
+- Extraire les informations structurées (IBAN, BIC) depuis le texte libre
+
+### 4. Extraction automatique
+
+**IBAN:**
+- Détection automatique des IBAN dans les champs `:50K:` et `:59:`
+- Validation de la longueur (15-34 caractères)
+- Nettoyage automatique (suppression des espaces)
+
+**BIC:**
+- Extraction depuis les champs `:52A:`, `:56A:`, `:57A:`
+- Validation du format (8 ou 11 caractères)
+- Pattern matching robuste
+
+### 5. Support des formats de date
+
+**Format :32A:**
+- Support YYMMDD (6 chiffres) → conversion automatique en YYYYMMDD
+- Support YYYYMMDD (8 chiffres)
+- Logique intelligente pour les années (YY < 50 → 20YY, sinon 19YY)
+
+### 6. Validation stricte
+
+**Validations implémentées:**
+- Dates: format YYYYMMDD avec vérification des valeurs
+- Devises: codes ISO 3 lettres majuscules
+- Montants: nombres positifs avec gestion des virgules/points
+- BIC: longueur 8 ou 11 caractères
+- Charges: valeurs strictes (OUR, SHA, BEN)
+
+### 7. Structure de données typée
+
+**Modèle Pydantic:** `SwiftMT103Parsed`
+
+```python
+class SwiftMT103Parsed(BaseModel):
+    field_20: str  # Référence
+    field_32A: SwiftField32A  # Date, devise, montant (validé)
+    field_50K: str  # Ordre donneur
+    field_59: str  # Bénéficiaire
+    # ... tous les champs optionnels
+    ordering_customer_account: Optional[str]  # IBAN extrait
+    beneficiary_account: Optional[str]  # IBAN extrait
+```
+
+### 8. Fonctionnalités supplémentaires
+
+**Formatage inverse:**
+- `format_swift_mt103_from_parsed()` - Reconstitution du message SWIFT depuis une structure parsée
+
+**Gestion d'erreurs:**
+- Messages d'erreur détaillés pour faciliter le débogage
+- Fallback vers extraction LLM si le parsing échoue
+
+## Utilisation
+
+### Parser basique (ancienne fonction)
+
+```python
+from examples.agent_swift import parse_swift_mt103
+
+swift_text = """
+:20:NONREF
+:23B:CRED
+:32A:241215EUR15000.00
+:50K:/FR76300040000100000000000123
+ORDRE DUPONT JEAN
+:59:/FR1420041010050500013M02606
+BENEFICIAIRE MARTIN
+:71A:OUR
+"""
+
+parsed = parse_swift_mt103(swift_text)
+```
+
+### Parser avancé (recommandé)
+
+```python
+from examples.swift_extractor import parse_swift_mt103_advanced
+
+parsed = parse_swift_mt103_advanced(swift_text)
+
+# Accès aux données validées
+print(parsed.field_32A.amount)  # 15000.0
+print(parsed.field_32A.currency)  # EUR
+print(parsed.field_32A.value_date)  # 20241215
+print(parsed.ordering_customer_account)  # FR76300040000100000000000123
+```
+
+### Avec agent PydanticAI
+
+```python
+from examples.agent_swift import swift_parser
+
+result = await swift_parser.run(f"Parse ce message SWIFT:\n{swift_text}")
+# L'agent utilise le parser avancé en arrière-plan
+```
+
+## Améliorations futures possibles
+
+1. **Support MT940** (relevés bancaires)
+2. **Support MT202** (transferts interbancaires)
+3. **Validation IBAN** (algorithme de contrôle)
+4. **Cache de parsing** pour performance
+5. **Mode strict vs permissif** pour différents niveaux de validation
+
+## Tests
+
+Tous les parsers sont testés avec:
+- Messages SWIFT standards
+- Formats YYMMDD et YYYYMMDD
+- Champs multi-lignes complexes
+- Champs optionnels
+- Cas limites (montants avec virgules, IBAN avec espaces, etc.)
+
+
+
+
+
+
+
+
+

examples/agent_1_structured_data.py

@@ -0,0 +1,78 @@
+"""
+Agent 1: Extraction et validation de données financières structurées
+
+Cet agent démontre l'utilisation de PydanticAI pour extraire et valider
+des données structurées à partir de textes financiers non structurés.
+"""
+
+import asyncio
+from pydantic import BaseModel, Field
+from pydantic_ai import Agent, ModelSettings
+
+from app.models import finance_model
+
+
+# Modèles de données structurées
+class PositionBoursiere(BaseModel):
+    """Représente une position boursière."""
+    symbole: str = Field(description="Symbole de l'action (ex: AIR.PA, SAN.PA)")
+    quantite: int = Field(description="Nombre d'actions", ge=0)
+    prix_achat: float = Field(description="Prix d'achat unitaire en euros", ge=0)
+    date_achat: str = Field(description="Date d'achat au format YYYY-MM-DD")
+
+
+class Portfolio(BaseModel):
+    """Portfolio avec positions boursières."""
+    positions: list[PositionBoursiere] = Field(description="Liste des positions")
+    valeur_totale: float = Field(description="Valeur totale du portfolio en euros", ge=0)
+    date_evaluation: str = Field(description="Date d'évaluation")
+
+
+# Agent pour extraction de données structurées
+extract_agent = Agent(
+    finance_model,
+    model_settings=ModelSettings(max_output_tokens=1200),  # Sufficient for structured data extraction
+    system_prompt=(
+        "Vous êtes un assistant expert en analyse de données financières. "
+        "Votre rôle est d'extraire des informations structurées à partir "
+        "de textes non structurés concernant des portfolios d'actions françaises. "
+        "Identifiez les symboles, quantités, prix d'achat et dates. "
+        "Calculez la valeur totale du portfolio."
+    ),
+)
+
+
+async def exemple_extraction_portfolio():
+    """Exemple d'extraction de données de portfolio."""
+    texte_non_structure = """
+    Mon portfolio actuel :
+    - J'ai acheté 50 actions Airbus (AIR.PA) à 120€ le 15 mars 2024
+    - 30 actions Sanofi (SAN.PA) à 85€ le 20 février 2024  
+    - 100 actions TotalEnergies (TTE.PA) à 55€ le 10 janvier 2024
+    
+    Date d'évaluation : 1er novembre 2024
+    """
+    
+    print("📊 Agent 1: Extraction de données structurées")
+    print("=" * 60)
+    print(f"Texte d'entrée:\n{texte_non_structure}\n")
+    
+    result = await extract_agent.run(
+        f"Extrais les informations du portfolio suivant et formate-les de manière structurée:\n{texte_non_structure}\n\n"
+        "Réponds avec:\n- Le nombre de positions\n- Les détails de chaque position (symbole, quantité, prix, date)\n- La valeur totale estimée"
+    )
+    
+    # Parser la réponse texte (simplifié pour l'exemple)
+    response = result.output
+    # En production, on utiliserait output_type=Portfolio pour validation automatique
+    print("✅ Résultat structuré:")
+    print(response)
+    print("\n💡 Note: Avec output_type=Portfolio, PydanticAI validerait")
+    print("   automatiquement la structure et fournirait un objet typé.")
+    
+    return response
+
+
+if __name__ == "__main__":
+    asyncio.run(exemple_extraction_portfolio())
+

examples/agent_2_tools.py

@@ -0,0 +1,139 @@
+"""
+Agent 2: Agent avec outils (Tools) pour calculs financiers
+
+Cet agent démontre l'utilisation d'outils Python que l'agent peut appeler
+pour effectuer des calculs financiers complexes.
+"""
+
+import asyncio
+from typing import Annotated
+from pydantic import BaseModel
+from pydantic_ai import Agent, ModelSettings
+
+from app.models import finance_model
+
+
+# Outils que l'agent peut utiliser
+def calculer_valeur_future(
+    capital_initial: float,
+    taux_annuel: float,
+    duree_annees: float
+) -> str:
+    """Calcule la valeur future avec intérêts composés.
+    
+    Args:
+        capital_initial: Montant initial en euros
+        taux_annuel: Taux d'intérêt annuel (ex: 0.05 pour 5%)
+        duree_annees: Durée en années
+    
+    Returns:
+        Valeur future calculée
+    """
+    valeur_future = capital_initial * (1 + taux_annuel) ** duree_annees
+    interets = valeur_future - capital_initial
+    return (
+        f"Valeur future: {valeur_future:,.2f}€\n"
+        f"Intérêts générés: {interets:,.2f}€\n"
+        f"Capital initial: {capital_initial:,.2f}€"
+    )
+
+
+def calculer_versement_mensuel(
+    capital_emprunte: float,
+    taux_annuel: float,
+    duree_mois: int
+) -> str:
+    """Calcule le versement mensuel pour un prêt.
+    
+    Args:
+        capital_emprunte: Montant emprunté en euros
+        taux_annuel: Taux d'intérêt annuel (ex: 0.04 pour 4%)
+        duree_mois: Durée du prêt en mois
+    
+    Returns:
+        Versement mensuel calculé
+    """
+    taux_mensuel = taux_annuel / 12
+    versement = capital_emprunte * (
+        taux_mensuel * (1 + taux_mensuel) ** duree_mois
+    ) / ((1 + taux_mensuel) ** duree_mois - 1)
+    
+    total_rembourse = versement * duree_mois
+    cout_total = total_rembourse - capital_emprunte
+    
+    return (
+        f"Versement mensuel: {versement:,.2f}€\n"
+        f"Total remboursé: {total_rembourse:,.2f}€\n"
+        f"Coût total du crédit: {cout_total:,.2f}€"
+    )
+
+
+def calculer_performance_portfolio(
+    valeur_initiale: float,
+    valeur_actuelle: float,
+    duree_jours: int
+) -> str:
+    """Calcule la performance d'un portfolio.
+    
+    Args:
+        valeur_initiale: Valeur initiale en euros
+        valeur_actuelle: Valeur actuelle en euros
+        duree_jours: Durée en jours
+    
+    Returns:
+        Performance calculée
+    """
+    gain_absolu = valeur_actuelle - valeur_initiale
+    gain_pourcentage = (gain_absolu / valeur_initiale) * 100
+    rendement_annuelise = ((valeur_actuelle / valeur_initiale) ** (365 / duree_jours) - 1) * 100
+    
+    return (
+        f"Gain absolu: {gain_absolu:+,.2f}€ ({gain_pourcentage:+.2f}%)\n"
+        f"Rendement annualisé: {rendement_annuelise:+.2f}%\n"
+        f"Durée: {duree_jours} jours"
+    )
+
+
+# Agent avec outils
+finance_calculator_agent = Agent(
+    finance_model,
+    model_settings=ModelSettings(max_output_tokens=1500),  # For explanations with calculations
+    system_prompt=(
+        "Vous êtes un conseiller financier expert. "
+        "Quand un client vous pose une question nécessitant un calcul financier, "
+        "utilisez les outils de calcul disponibles pour fournir des résultats précis. "
+        "Expliquez toujours les résultats dans le contexte de la question du client. "
+        "Répondez en français."
+    ),
+    tools=[calculer_valeur_future, calculer_versement_mensuel, calculer_performance_portfolio],
+)
+
+
+async def exemple_agent_avec_outils():
+    """Exemple d'utilisation d'un agent avec outils."""
+    print("\n🔧 Agent 2: Agent avec outils de calcul")
+    print("=" * 60)
+    
+    question = (
+        "J'ai un capital de 50 000€ que je veux placer à 4% par an pendant 10 ans. "
+        "Combien aurai-je à la fin ? Et si j'emprunte 200 000€ sur 20 ans à 3.5% "
+        "pour acheter un appartement, combien paierai-je par mois ?"
+    )
+    
+    print(f"Question:\n{question}\n")
+    
+    result = await finance_calculator_agent.run(question)
+    
+    print("✅ Réponse de l'agent avec calculs:")
+    print(result.output)
+    print()
+    
+    # Afficher quels outils ont été utilisés
+    if hasattr(result, 'usage') and result.usage:
+        print("📊 Utilisation des outils:")
+        print(f"  - Tokens utilisés: {result.usage.total_tokens if hasattr(result.usage, 'total_tokens') else 'N/A'}")
+
+
+if __name__ == "__main__":
+    asyncio.run(exemple_agent_avec_outils())
+

examples/agent_3_multi_step.py

@@ -0,0 +1,152 @@
+"""
+Agent 3: Workflow multi-étapes avec agents spécialisés
+
+Cet agent démontre la création d'un workflow où plusieurs agents spécialisés
+collaborent pour résoudre un problème financier complexe.
+"""
+
+import asyncio
+from pydantic import BaseModel, Field
+from pydantic_ai import Agent, ModelSettings
+
+from app.models import finance_model
+
+
+# Agents spécialisés avec limites appropriées
+risk_analyst = Agent(
+    finance_model,
+    model_settings=ModelSettings(max_output_tokens=1200),  # Risk analysis
+    system_prompt=(
+        "Vous êtes un analyste de risque financier. "
+        "Vous évaluez les risques associés à différents instruments financiers "
+        "et stratégies d'investissement. "
+        "Fournissez une évaluation de risque sur 5 niveaux (1=très faible, 5=très élevé)."
+    ),
+)
+
+tax_advisor = Agent(
+    finance_model,
+    model_settings=ModelSettings(max_output_tokens=1500),  # Tax advice can be detailed
+    system_prompt=(
+        "Vous êtes un conseiller fiscal français. "
+        "Vous expliquez les implications fiscales des investissements "
+        "selon la réglementation française (PEA, assurance-vie, compte-titres, etc.)."
+    ),
+)
+
+portfolio_optimizer = Agent(
+    finance_model,
+    model_settings=ModelSettings(max_output_tokens=2000),  # Portfolio optimization can be complex
+    system_prompt=(
+        "Vous êtes un optimiseur de portfolio. "
+        "Vous proposez des allocations d'actifs optimisées "
+        "en fonction des objectifs, de l'horizon temporel et du profil de risque. "
+        "Répondez toujours en français."
+    ),
+)
+
+
+class AnalyseRisque(BaseModel):
+    """Analyse de risque."""
+    niveau_risque: int = Field(description="Niveau de risque de 1 à 5", ge=1, le=5)
+    facteurs_risque: list[str] = Field(description="Liste des facteurs de risque identifiés")
+    recommandation: str = Field(description="Recommandation basée sur le niveau de risque")
+
+
+async def workflow_analyse_investissement():
+    """Workflow multi-étapes pour analyser un investissement."""
+    print("\n🔄 Agent 3: Workflow multi-étapes")
+    print("=" * 60)
+    
+    scenario = """
+    Un investisseur de 35 ans avec un profil modéré souhaite investir 100 000€.
+    Objectif: Préparer la retraite dans 30 ans.
+    Il envisage:
+    - 40% en actions françaises (CAC 40)
+    - 30% en obligations d'État
+    - 20% en immobiler via SCPI
+    - 10% en cryptomonnaies
+    
+    Analysez ce portfolio du point de vue:
+    1. Risque
+    2. Fiscalité
+    3. Optimisation
+    """
+    
+    print("Scénario:\n", scenario, "\n")
+    
+    # Étape 1: Analyse de risque
+    print("📊 Étape 1: Analyse de risque...")
+    risk_result = await risk_analyst.run(
+        f"Analyse le niveau de risque (1-5) de cette stratégie:\n{scenario}\n\n"
+        "Fournis: niveau de risque (1-5), facteurs de risque principaux, et recommandation."
+    )
+    risk_output = risk_result.output
+    print(f"  Analyse:\n  {risk_output[:300]}...\n")
+    
+    # Étape 2: Conseil fiscal
+    print("💰 Étape 2: Analyse fiscale...")
+    tax_result = await tax_advisor.run(
+        f"Quelles sont les implications fiscales de cette stratégie d'investissement "
+        f"en France?\n{scenario}"
+    )
+    print(f"  Conseil fiscal:\n  {tax_result.output[:300]}...\n")
+    
+    # Étape 3: Optimisation avec contexte des étapes précédentes
+    print("🎯 Étape 3: Optimisation du portfolio...")
+    optimization_result = await portfolio_optimizer.run(
+        f"""
+        Scénario: {scenario}
+        
+        Analyses précédentes:
+        - Analyse de risque: {risk_output[:200]}
+        - Analyse fiscale: {tax_result.output[:200]}
+        
+        Propose une allocation optimisée en tenant compte de ces analyses.
+        """
+    )
+    print(f"  Recommandation d'optimisation:\n  {optimization_result.output[:400]}...\n")
+    
+    # Résumé final
+    print("✅ Workflow terminé avec succès!")
+    print(f"  - Analyse de risque: Complétée")
+    print(f"  - Conseils fiscaux: Fournis")
+    print(f"  - Optimisation: Recommandation générée")
+
+
+async def exemple_agent_simple():
+    """Exemple simplifié d'un agent qui fait tout en une étape."""
+    print("\n🚀 Agent 3 (Variante): Agent tout-en-un")
+    print("=" * 60)
+    
+    multi_agent = Agent(
+        finance_model,
+        model_settings=ModelSettings(max_output_tokens=2000),  # Complete analysis needs more tokens
+        system_prompt=(
+            "Vous êtes un conseiller financier complet. "
+            "Pour chaque demande d'analyse, fournissez:\n"
+            "1. Une évaluation du risque (1-5)\n"
+            "2. Les implications fiscales en France\n"
+            "3. Une recommandation d'optimisation\n"
+            "Répondez toujours en français de manière structurée."
+        ),
+    )
+    
+    question = (
+        "J'ai 50 000€ à investir avec un horizon de 15 ans. "
+        "Je pense à 60% actions, 30% obligations, 10% immobilier. "
+        "Analysez cette stratégie."
+    )
+    
+    result = await multi_agent.run(question)
+    print(f"Question: {question}\n")
+    print(f"Analyse complète:\n{result.output[:500]}...")
+
+
+if __name__ == "__main__":
+    print("Exécution du workflow multi-étapes...")
+    asyncio.run(workflow_analyse_investissement())
+    
+    print("\n\n" + "=" * 60)
+    asyncio.run(exemple_agent_simple())
+

examples/agent_swift.py

@@ -0,0 +1,540 @@
+"""
+Agent SWIFT: Génération et parsing de messages SWIFT structurés
+
+Cet agent démontre l'utilisation de PydanticAI pour:
+- Générer des messages SWIFT formatés depuis du texte naturel
+- Extraire les données structurées d'un message SWIFT
+- Valider la structure des messages SWIFT
+"""
+
+import asyncio
+import re
+from typing import Optional
+from pydantic import BaseModel, Field, field_validator
+from pydantic_ai import Agent, ModelSettings
+
+from app.models import finance_model
+
+# Imports relatifs pour les modules dans examples/
+try:
+    from .swift_models import SWIFTMT103Structured, MT103Field32A
+    from .swift_extractor import (
+        parse_swift_mt103_advanced,
+        SwiftMT103Parsed,
+        format_swift_mt103_from_parsed,
+    )
+except ImportError:
+    # Fallback pour exécution directe
+    import sys
+    from pathlib import Path
+    sys.path.insert(0, str(Path(__file__).parent))
+    from swift_models import SWIFTMT103Structured, MT103Field32A
+    from swift_extractor import (
+        parse_swift_mt103_advanced,
+        SwiftMT103Parsed,
+        format_swift_mt103_from_parsed,
+    )
+
+# Model settings for SWIFT generation (complex structured output)
+swift_model_settings = ModelSettings(
+    max_output_tokens=2000,  # Increased for SWIFT message generation
+)
+
+
+# Modèle pour un message SWIFT MT103 (Transfert de fonds)
+class SWIFTMT103(BaseModel):
+    """Message SWIFT MT103 - Transfert de fonds unique."""
+    
+    # En-tête
+    message_type: str = Field(default="103", description="Type de message SWIFT (103)")
+    sender_bic: str = Field(description="BIC de la banque émettrice (8 ou 11 caractères)")
+    receiver_bic: str = Field(description="BIC de la banque réceptrice (8 ou 11 caractères)")
+    
+    # Champs obligatoires
+    value_date: str = Field(description="Date de valeur au format YYYYMMDD")
+    currency: str = Field(description="Code devise ISO (3 lettres)", min_length=3, max_length=3)
+    amount: float = Field(description="Montant du transfert", gt=0)
+    
+    # Champs optionnels
+    ordering_customer: str = Field(description="Données de l'ordre donneur (nom, adresse, compte)")
+    beneficiary: str = Field(description="Données du bénéficiaire (nom, adresse, compte)")
+    remittance_info: str | None = Field(default=None, description="Information pour le bénéficiaire")
+    charges: str = Field(default="OUR", description="Frais: OUR, SHA, BEN")
+    reference: str | None = Field(default=None, description="Référence du transfert")
+
+
+class SWIFTMT940(BaseModel):
+    """Message SWIFT MT940 - Relevé bancaire."""
+    
+    message_type: str = Field(default="940", description="Type de message SWIFT (940)")
+    account_identification: str = Field(description="Identification du compte (IBAN)")
+    statement_number: str = Field(description="Numéro de relevé")
+    opening_balance_date: str = Field(description="Date de solde d'ouverture YYYYMMDD")
+    opening_balance: float = Field(description="Solde d'ouverture")
+    opening_balance_indicator: str = Field(description="C (Crédit) ou D (Débit)")
+    currency: str = Field(description="Code devise ISO (3 lettres)")
+    transactions: list[dict[str, str | float]] = Field(description="Liste des transactions")
+
+
+# Agent pour génération de messages SWIFT
+swift_generator = Agent(
+    finance_model,
+    model_settings=swift_model_settings,
+    system_prompt=(
+        "Vous êtes un expert en messages SWIFT bancaires. "
+        "Votre rôle est de générer des messages SWIFT correctement formatés "
+        "à partir de descriptions en langage naturel. "
+        "Les messages SWIFT doivent être conformes aux standards internationaux. "
+        "Pour les montants, utilisez toujours le format numérique avec 2 décimales. "
+        "Les BIC doivent être valides (8 ou 11 caractères alphanumériques). "
+        "Répondez en français mais générez les messages SWIFT au format standard.\n\n"
+        "Vous disposez de 2000 tokens pour générer des messages SWIFT complets et détaillés."
+    ),
+)
+
+
+# Agent pour parsing de messages SWIFT avec extraction structurée
+swift_parser = Agent(
+    finance_model,
+    model_settings=ModelSettings(max_output_tokens=2000),
+    system_prompt=(
+        "Vous êtes un expert en parsing de messages SWIFT bancaires. "
+        "Votre rôle est d'extraire précisément toutes les informations "
+        "à partir de messages SWIFT formatés (MT103, MT940, etc.).\n\n"
+        "Instructions importantes:\n"
+        "- Identifiez TOUS les champs SWIFT présents (même optionnels)\n"
+        "- Pour le champ :32A:, extrayez séparément la date (YYYYMMDD), devise (3 lettres), et montant\n"
+        "- Pour les champs :50K: et :59:, conservez toutes les lignes (nom, adresse, compte)\n"
+        "- Les dates doivent être au format YYYYMMDD\n"
+        "- Les montants doivent être numériques avec décimales\n"
+        "- Les BIC doivent être extraits des champs :52A:, :56A:, etc. si présents\n"
+        "- Répondez en JSON structuré pour faciliter le parsing"
+    ),
+)
+
+
+def format_swift_mt103(mt103: SWIFTMT103) -> str:
+    """Formate un message SWIFT MT103 selon les standards."""
+    lines = []
+    
+    # En-tête SWIFT
+    lines.append(f":20:{mt103.reference or 'NONREF'}")
+    lines.append(f":23B:CRED")
+    lines.append(f":32A:{mt103.value_date}{mt103.currency}{mt103.amount:.2f}")
+    lines.append(f":50K:/{mt103.ordering_customer}")
+    lines.append(f":59:/{mt103.beneficiary}")
+    
+    if mt103.remittance_info:
+        lines.append(f":70:{mt103.remittance_info}")
+    
+    lines.append(f":71A:{mt103.charges}")
+    
+    return "\n".join(lines)
+
+
+class SWIFTExtractedMT103(BaseModel):
+    """Structure extraite d'un message SWIFT MT103."""
+    
+    # Champ :20: - Référence du transfert
+    reference: str = Field(description="Référence du transfert (:20:)")
+    
+    # Champ :23B: - Code instruction
+    instruction_code: str = Field(default="CRED", description="Code instruction (:23B:)")
+    
+    # Champ :32A: - Date de valeur, devise, montant
+    value_date: str = Field(description="Date de valeur YYYYMMDD")
+    currency: str = Field(description="Code devise ISO 3 lettres")
+    amount: float = Field(description="Montant", gt=0)
+    
+    # Champ :50K: ou :50A: - Ordre donneur (peut être multi-lignes)
+    ordering_customer: str = Field(description="Données ordonnateur (:50K: ou :50A:)")
+    ordering_customer_account: Optional[str] = Field(default=None, description="Compte ordonnateur (IBAN)")
+    
+    # Champ :52A:, :52D: - Banque ordonnateur (optionnel)
+    ordering_bank_bic: Optional[str] = Field(default=None, description="BIC banque ordonnateur (:52A:)")
+    ordering_bank_name: Optional[str] = Field(default=None, description="Nom banque ordonnateur (:52D:)")
+    
+    # Champ :56A:, :56D: - Banque intermédiaire (optionnel)
+    intermediary_bank_bic: Optional[str] = Field(default=None, description="BIC banque intermédiaire (:56A:)")
+    intermediary_bank_name: Optional[str] = Field(default=None, description="Nom banque intermédiaire (:56D:)")
+    
+    # Champ :57A:, :57D: - Banque bénéficiaire (optionnel)
+    beneficiary_bank_bic: Optional[str] = Field(default=None, description="BIC banque bénéficiaire (:57A:)")
+    beneficiary_bank_name: Optional[str] = Field(default=None, description="Nom banque bénéficiaire (:57D:)")
+    
+    # Champ :59: ou :59A: - Bénéficiaire (peut être multi-lignes)
+    beneficiary: str = Field(description="Données bénéficiaire (:59: ou :59A:)")
+    beneficiary_account: Optional[str] = Field(default=None, description="Compte bénéficiaire (IBAN)")
+    
+    # Champ :70: - Information pour le bénéficiaire (optionnel)
+    remittance_info: Optional[str] = Field(default=None, description="Information bénéficiaire (:70:)")
+    
+    # Champ :71A: - Frais
+    charges: str = Field(default="OUR", description="Frais: OUR/SHA/BEN (:71A:)")
+    
+    # Champ :72: - Information pour la banque (optionnel)
+    bank_to_bank_info: Optional[str] = Field(default=None, description="Info banque à banque (:72:)")
+    
+    @field_validator("value_date")
+    def validate_date(cls, v):
+        if len(v) != 8 or not v.isdigit():
+            raise ValueError(f"Date must be YYYYMMDD format, got: {v}")
+        return v
+    
+    @field_validator("currency")
+    def validate_currency(cls, v):
+        if len(v) != 3 or not v.isalpha():
+            raise ValueError(f"Currency must be 3 letter ISO code, got: {v}")
+        return v.upper()
+    
+    @field_validator("charges")
+    def validate_charges(cls, v):
+        valid = ["OUR", "SHA", "BEN"]
+        if v not in valid:
+            raise ValueError(f"Charges must be one of {valid}, got: {v}")
+        return v
+
+
+def parse_swift_mt103(swift_text: str) -> SWIFTExtractedMT103:
+    """
+    Parse un message SWIFT MT103 et extrait tous les champs avec validation.
+    
+    Gère:
+    - Champs multi-lignes (:50K:, :59:, etc.)
+    - Champs optionnels
+    - Extraction des BIC et noms de banques
+    - Validation des formats (dates, devises, montants)
+    """
+    # Nettoyer le texte
+    lines = [line.strip() for line in swift_text.strip().split("\n") if line.strip()]
+    
+    parsed_data = {
+        "reference": "NONREF",
+        "instruction_code": "CRED",
+        "charges": "OUR",
+    }
+    
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+        
+        # Champ :20: - Référence
+        if line.startswith(":20:"):
+            parsed_data["reference"] = line[4:].strip()
+        
+        # Champ :23B: - Code instruction
+        elif line.startswith(":23B:"):
+            parsed_data["instruction_code"] = line[5:].strip()
+        
+        # Champ :32A: - Date, devise, montant (format: YYYYMMDD + 3 lettres + montant)
+        elif line.startswith(":32A:"):
+            value = line[5:].strip()
+            if len(value) >= 11:
+                parsed_data["value_date"] = value[:8]
+                parsed_data["currency"] = value[8:11].upper()
+                try:
+                    parsed_data["amount"] = float(value[11:].replace(",", "."))
+                except ValueError:
+                    raise ValueError(f"Invalid amount format in :32A: {value[11:]}")
+        
+        # Champ :50K:, :50A:, :50F: - Ordre donneur (peut être multi-lignes)
+        elif line.startswith(":50") and ":" in line:
+            tag_end = line.index(":")
+            tag = line[:tag_end+1]
+            content_parts = [line[tag_end+1:].strip()]
+            i += 1
+            
+            # Lire les lignes suivantes jusqu'au prochain tag
+            while i < len(lines) and not lines[i].startswith(":"):
+                if lines[i].strip():
+                    content_parts.append(lines[i].strip())
+                i += 1
+            i -= 1  # Revenir en arrière car on a avancé trop loin
+            
+            full_content = "\n".join(content_parts)
+            parsed_data["ordering_customer"] = full_content
+            
+            # Extraire le compte (IBAN) si présent
+            iban_match = re.search(r'([A-Z]{2}\d{2}[A-Z0-9\s]{12,34})', full_content)
+            if iban_match:
+                parsed_data["ordering_customer_account"] = iban_match.group(1).replace(" ", "")
+        
+        # Champ :52A:, :52D: - Banque ordonnateur
+        elif line.startswith(":52A:"):
+            parsed_data["ordering_bank_bic"] = line[5:].strip()[:11]
+        elif line.startswith(":52D:"):
+            parsed_data["ordering_bank_name"] = line[5:].strip()
+        
+        # Champ :56A:, :56D: - Banque intermédiaire
+        elif line.startswith(":56A:"):
+            parsed_data["intermediary_bank_bic"] = line[5:].strip()[:11]
+        elif line.startswith(":56D:"):
+            parsed_data["intermediary_bank_name"] = line[5:].strip()
+        
+        # Champ :57A:, :57D: - Banque bénéficiaire
+        elif line.startswith(":57A:"):
+            parsed_data["beneficiary_bank_bic"] = line[5:].strip()[:11]
+        elif line.startswith(":57D:"):
+            parsed_data["beneficiary_bank_name"] = line[5:].strip()
+        
+        # Champ :59:, :59A: - Bénéficiaire (peut être multi-lignes)
+        elif line.startswith(":59"):
+            tag_end = line.index(":")
+            tag = line[:tag_end+1]
+            content_parts = [line[tag_end+1:].strip()]
+            i += 1
+            
+            # Lire les lignes suivantes jusqu'au prochain tag
+            while i < len(lines) and not lines[i].startswith(":"):
+                if lines[i].strip():
+                    content_parts.append(lines[i].strip())
+                i += 1
+            i -= 1
+            
+            full_content = "\n".join(content_parts)
+            parsed_data["beneficiary"] = full_content
+            
+            # Extraire le compte (IBAN) si présent
+            iban_match = re.search(r'([A-Z]{2}\d{2}[A-Z0-9\s]{12,34})', full_content)
+            if iban_match:
+                parsed_data["beneficiary_account"] = iban_match.group(1).replace(" ", "")
+        
+        # Champ :70: - Information pour bénéficiaire
+        elif line.startswith(":70:"):
+            content_parts = [line[4:].strip()]
+            i += 1
+            while i < len(lines) and not lines[i].startswith(":"):
+                if lines[i].strip():
+                    content_parts.append(lines[i].strip())
+                i += 1
+            i -= 1
+            parsed_data["remittance_info"] = "\n".join(content_parts)
+        
+        # Champ :71A: - Frais
+        elif line.startswith(":71A:"):
+            parsed_data["charges"] = line[5:].strip()
+        
+        # Champ :72: - Information banque à banque
+        elif line.startswith(":72:"):
+            content_parts = [line[4:].strip()]
+            i += 1
+            while i < len(lines) and not lines[i].startswith(":"):
+                if lines[i].strip():
+                    content_parts.append(lines[i].strip())
+                i += 1
+            i -= 1
+            parsed_data["bank_to_bank_info"] = "\n".join(content_parts)
+        
+        i += 1
+    
+    # Valider que les champs obligatoires sont présents
+    required_fields = ["value_date", "currency", "amount", "ordering_customer", "beneficiary"]
+    missing = [f for f in required_fields if f not in parsed_data]
+    if missing:
+        raise ValueError(f"Missing required fields: {missing}")
+    
+    return SWIFTExtractedMT103(**parsed_data)
+
+
+async def exemple_generation_swift():
+    """Exemple de génération d'un message SWIFT MT103."""
+    print("📨 Agent SWIFT: Génération de message MT103")
+    print("=" * 60)
+    
+    demande = """
+    Je veux transférer 15 000 euros de mon compte à la BNP Paribas (BIC: BNPAFRPPXXX)
+    vers le compte de Jean Dupont à la Société Générale (BIC: SOGEFRPPXXX)
+    le 15 décembre 2024.
+    
+    Mon compte: FR76 3000 4000 0100 0000 0000 123
+    Compte bénéficiaire: FR14 2004 1010 0505 0001 3M02 606
+    Référence: INVOICE-2024-001
+    Motif: Paiement facture décembre 2024
+    Les frais sont à ma charge.
+    """
+    
+    print(f"Demande:\n{demande}\n")
+    
+    prompt = f"""
+    Génère un message SWIFT MT103 à partir de cette demande:
+    {demande}
+    
+    Fournis les informations structurées suivantes:
+    - BIC émetteur et récepteur
+    - Date de valeur (format YYYYMMDD)
+    - Devise et montant
+    - Données ordonnateur et bénéficiaire
+    - Référence et motif
+    - Qui paie les frais (OUR = ordonnateur, SHA = partagé, BEN = bénéficiaire)
+    """
+    
+    result = await swift_generator.run(prompt)
+    
+    print("✅ Message SWIFT généré:")
+    print(result.output)
+    print()
+    
+    # Extraire les données structurées depuis la réponse avec validation
+    print("📊 Extraction des données structurées...")
+    
+    # D'abord, extraire le message SWIFT brut (sans les explications)
+    swift_lines = []
+    for line in result.output.split("\n"):
+        if line.strip().startswith(":") and ":" in line:
+            swift_lines.append(line.strip())
+    
+    if swift_lines:
+        swift_message = "\n".join(swift_lines)
+        print("Message SWIFT extrait:")
+        print(swift_message)
+        print()
+        
+        # Parser avec validation Pydantic avancée
+        try:
+            extracted = parse_swift_mt103_advanced(swift_message)
+            print("✅ Données extraites et validées:")
+            print(f"  Référence: {extracted.field_20}")
+            print(f"  Date: {extracted.field_32A.value_date}")
+            print(f"  Montant: {extracted.field_32A.amount:,.2f} {extracted.field_32A.currency}")
+            print(f"  Ordonnateur: {extracted.field_50K[:50]}...")
+            print(f"  Bénéficiaire: {extracted.field_59[:50]}...")
+            print(f"  Frais: {extracted.field_71A}")
+        except Exception as e:
+            print(f"⚠️ Erreur de parsing structuré: {e}")
+            # Fallback: extraction via LLM
+            extraction = await swift_parser.run(
+                f"Extrais les données structurées du message SWIFT suivant:\n{swift_message}"
+            )
+            print(extraction.output[:500])
+    else:
+        # Fallback si aucun format SWIFT détecté
+        extraction = await swift_parser.run(
+            f"Extrais les données structurées du message SWIFT suivant:\n{result.output}"
+        )
+        print(extraction.output[:500])
+
+
+async def exemple_parsing_swift():
+    """Exemple de parsing d'un message SWIFT existant."""
+    print("\n🔍 Agent SWIFT: Parsing de message MT103")
+    print("=" * 60)
+    
+    swift_message = """
+:20:NONREF
+:23B:CRED
+:32A:241215EUR15000.00
+:50K:/FR76300040000100000000000123
+ORDRE DUPONT JEAN
+RUE DE LA REPUBLIQUE 123
+75001 PARIS FRANCE
+
+:59:/FR1420041010050500013M02606
+BENEFICIAIRE MARTIN PIERRE
+AVENUE DES CHAMPS ELYSEES 456
+75008 PARIS FRANCE
+
+:70:Paiement facture décembre 2024
+:71A:OUR
+    """
+    
+    print("Message SWIFT à parser:\n")
+    print(swift_message)
+    print()
+    
+    result = await swift_parser.run(
+        f"Parse ce message SWIFT MT103 et extrais toutes les informations:\n{swift_message}\n\n"
+        "Fournis:\n- Type de message\n- Date de valeur\n- Montant et devise\n"
+        "- Données ordonnateur\n- Données bénéficiaire\n- Référence et motif\n- Frais"
+    )
+    
+    print("✅ Données extraites:")
+    print(result.output)
+    
+    # Parser technique avec validation Pydantic avancée
+    print("\n🔧 Parsing technique avec validation avancée:")
+    try:
+        # Utiliser le parser avancé
+        parsed = parse_swift_mt103_advanced(swift_message)
+        print("✅ Message SWIFT parsé et validé avec succès:")
+        print(f"  Référence (:20:): {parsed.field_20}")
+        print(f"  Code instruction (:23B:): {parsed.field_23B}")
+        print(f"  Date de valeur: {parsed.field_32A.value_date}")
+        print(f"  Devise: {parsed.field_32A.currency}")
+        print(f"  Montant: {parsed.field_32A.amount:,.2f} {parsed.field_32A.currency}")
+        print(f"  Ordonnateur (:50K:):\n    {parsed.field_50K.replace(chr(10), chr(10) + '    ')}")
+        if parsed.ordering_customer_account:
+            print(f"  → IBAN ordonnateur extrait: {parsed.ordering_customer_account}")
+        if parsed.field_52A:
+            print(f"  Banque ordonnateur (:52A:): {parsed.field_52A}")
+        if parsed.field_56A:
+            print(f"  Banque intermédiaire (:56A:): {parsed.field_56A}")
+        if parsed.field_57A:
+            print(f"  Banque bénéficiaire (:57A:): {parsed.field_57A}")
+        print(f"  Bénéficiaire (:59:):\n    {parsed.field_59.replace(chr(10), chr(10) + '    ')}")
+        if parsed.beneficiary_account:
+            print(f"  → IBAN bénéficiaire extrait: {parsed.beneficiary_account}")
+        if parsed.field_70:
+            print(f"  Motif (:70:): {parsed.field_70}")
+        print(f"  Frais (:71A:): {parsed.field_71A}")
+        if parsed.field_72:
+            print(f"  Info banque (:72:): {parsed.field_72}")
+    except Exception as e:
+        print(f"❌ Erreur lors du parsing: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+async def exemple_synthese_swift():
+    """Exemple de synthèse d'un message SWIFT depuis plusieurs sources."""
+    print("\n🔄 Agent SWIFT: Synthèse de message")
+    print("=" * 60)
+    
+    contexte = """
+    Informations de la transaction:
+    - Virement international de 50 000 USD
+    - De: ABC Bank New York (BIC: ABCDUS33XXX) vers XYZ Bank Paris (BIC: XYZDFRPPXXX)
+    - Date: 20 janvier 2025
+    - Compte ordonnateur: US64 SVBKUS6SXXX 123456789
+    - Compte bénéficiaire: FR76 3000 4000 0100 0000 0000 456
+    - Référence client: TXN-2025-001
+    - Motif: Paiement services consultance Q1 2025
+    - Frais partagés (SHA)
+    """
+    
+    print(f"Contexte:\n{contexte}\n")
+    
+    result = await swift_generator.run(
+        f"Génère un message SWIFT MT103 complet et correctement formaté:\n{contexte}\n\n"
+        "Assure-toi que:\n- Les BIC sont au bon format\n- La date est au format YYYYMMDD\n"
+        "- Le montant a 2 décimales\n- Les comptes incluent le code pays\n"
+        "- Tous les champs obligatoires sont présents"
+    )
+    
+    print("✅ Message SWIFT synthétisé:")
+    swift_msg = result.output
+    
+    # Extraire juste le format SWIFT si l'agent a ajouté des explications
+    swift_lines = []
+    for line in swift_msg.split("\n"):
+        if line.strip().startswith(":"):
+            swift_lines.append(line.strip())
+    
+    if swift_lines:
+        print("\n".join(swift_lines))
+    else:
+        print(swift_msg)
+
+
+if __name__ == "__main__":
+    print("\n" + "=" * 60)
+    print("EXEMPLES D'AGENTS SWIFT AVEC PYDANTICAI")
+    print("=" * 60 + "\n")
+    
+    asyncio.run(exemple_generation_swift())
+    asyncio.run(exemple_parsing_swift())
+    asyncio.run(exemple_synthese_swift())
+    
+    print("\n" + "=" * 60)
+    print("✅ Tous les exemples terminés!")
+    print("=" * 60)
+

examples/agent_with_tools_and_memory.py

@@ -0,0 +1,368 @@
+"""
+Agent avec outils financiers et mémoire (history)
+
+Cet exemple démontre:
+1. Utilisation d'outils Python pour calculs financiers
+2. Mémoire/conversation history pour maintenir le contexte
+3. Agents qui se souviennent des calculs précédents
+"""
+
+import asyncio
+from typing import Annotated, List
+from pydantic import BaseModel
+from pydantic_ai import Agent, ModelSettings
+
+from app.models import finance_model
+
+
+# Simple History wrapper for managing conversation
+class ConversationHistory:
+    """Gère l'historique de conversation pour les agents."""
+    
+    def __init__(self):
+        self.messages: List[dict] = []
+    
+    def add_user_message(self, content: str):
+        """Ajoute un message utilisateur."""
+        # Pour simplifier, on crée une structure simple
+        # En production, utiliser les types corrects de PydanticAI
+        self.messages.append({"role": "user", "content": content})
+    
+    def add_assistant_message(self, content: str):
+        """Ajoute un message assistant."""
+        self.messages.append({"role": "assistant", "content": content})
+    
+    def get_history_for_agent(self) -> List[dict]:
+        """Retourne l'historique au format pour l'agent."""
+        return self.messages
+    
+    def __len__(self):
+        return len(self.messages)
+
+# ============================================================================
+# OUTILS FINANCIERS
+# ============================================================================
+
+def calculer_valeur_future(
+    capital_initial: float,
+    taux_annuel: float,
+    duree_annees: float
+) -> str:
+    """Calcule la valeur future avec intérêts composés.
+    
+    Args:
+        capital_initial: Montant initial en euros
+        taux_annuel: Taux d'intérêt annuel (ex: 0.04 pour 4%)
+        duree_annees: Durée en années
+    
+    Returns:
+        Résultat formaté du calcul
+    """
+    valeur_future = capital_initial * (1 + taux_annuel) ** duree_annees
+    interets = valeur_future - capital_initial
+    rendement_pct = (interets / capital_initial) * 100
+    
+    return (
+        f"💰 Valeur future: {valeur_future:,.2f}€\n"
+        f"   Capital initial: {capital_initial:,.2f}€\n"
+        f"   Intérêts générés: {interets:,.2f}€ ({rendement_pct:.2f}%)\n"
+        f"   Durée: {duree_annees} ans à {taux_annuel*100:.2f}% par an"
+    )
+
+
+def calculer_versement_mensuel(
+    capital_emprunte: float,
+    taux_annuel: float,
+    duree_annees: int
+) -> str:
+    """Calcule le versement mensuel pour un prêt immobilier.
+    
+    Args:
+        capital_emprunte: Montant emprunté en euros
+        taux_annuel: Taux d'intérêt annuel (ex: 0.035 pour 3.5%)
+        duree_annees: Durée du prêt en années
+    
+    Returns:
+        Résultat formaté du calcul
+    """
+    duree_mois = duree_annees * 12
+    taux_mensuel = taux_annuel / 12
+    versement = capital_emprunte * (
+        taux_mensuel * (1 + taux_mensuel) ** duree_mois
+    ) / ((1 + taux_mensuel) ** duree_mois - 1)
+    
+    total_rembourse = versement * duree_mois
+    cout_total = total_rembourse - capital_emprunte
+    
+    return (
+        f"🏠 Versement mensuel: {versement:,.2f}€\n"
+        f"   Capital emprunté: {capital_emprunte:,.2f}€\n"
+        f"   Total remboursé: {total_rembourse:,.2f}€\n"
+        f"   Coût du crédit: {cout_total:,.2f}€\n"
+        f"   Durée: {duree_annees} ans ({duree_mois} mois) à {taux_annuel*100:.2f}%"
+    )
+
+
+def calculer_performance_portfolio(
+    valeur_initiale: float,
+    valeur_actuelle: float,
+    duree_jours: int
+) -> str:
+    """Calcule la performance d'un portfolio.
+    
+    Args:
+        valeur_initiale: Valeur initiale en euros
+        valeur_actuelle: Valeur actuelle en euros
+        duree_jours: Durée en jours
+    
+    Returns:
+        Résultat formaté du calcul
+    """
+    gain_absolu = valeur_actuelle - valeur_initiale
+    gain_pourcentage = (gain_absolu / valeur_initiale) * 100
+    rendement_annuelise = ((valeur_actuelle / valeur_initiale) ** (365 / duree_jours) - 1) * 100
+    
+    return (
+        f"📈 Performance portfolio:\n"
+        f"   Gain absolu: {gain_absolu:+,.2f}€ ({gain_pourcentage:+.2f}%)\n"
+        f"   Rendement annualisé: {rendement_annuelise:+.2f}%\n"
+        f"   Durée: {duree_jours} jours"
+    )
+
+
+def calculer_ratio_dette(
+    dette_totale: float,
+    revenus_annuels: float
+) -> str:
+    """Calcule le ratio d'endettement.
+    
+    Args:
+        dette_totale: Dette totale en euros
+        revenus_annuels: Revenus annuels en euros
+    
+    Returns:
+        Résultat formaté du calcul
+    """
+    ratio = (dette_totale / revenus_annuels) * 100
+    annees_remboursement = dette_totale / revenus_annuels
+    
+    return (
+        f"💳 Ratio d'endettement:\n"
+        f"   Ratio: {ratio:.2f}% des revenus annuels\n"
+        f"   Dette totale: {dette_totale:,.2f}€\n"
+        f"   Revenus annuels: {revenus_annuels:,.2f}€\n"
+        f"   Années de remboursement: {annees_remboursement:.2f} ans"
+    )
+
+
+# ============================================================================
+# AGENT AVEC OUTILS ET MÉMOIRE
+# ============================================================================
+
+finance_advisor = Agent(
+    finance_model,
+    model_settings=ModelSettings(max_output_tokens=2000),
+    system_prompt=(
+        "Vous êtes un conseiller financier expert qui aide les clients à prendre "
+        "des décisions financières éclairées. Vous avez accès à des outils de calcul "
+        "financier précis.\n\n"
+        "Utilisez les outils disponibles pour:\n"
+        "- Calculer les valeurs futures d'investissements\n"
+        "- Calculer les versements de prêts immobiliers\n"
+        "- Analyser la performance de portfolios\n"
+        "- Évaluer les ratios d'endettement\n\n"
+        "Gardez en mémoire les informations précédentes de la conversation pour "
+        "fournir des conseils cohérents et personnalisés.\n\n"
+        "Répondez toujours en français de manière claire et structurée."
+    ),
+    tools=[
+        calculer_valeur_future,
+        calculer_versement_mensuel,
+        calculer_performance_portfolio,
+        calculer_ratio_dette,
+    ],
+)
+
+
+# ============================================================================
+# EXEMPLES D'UTILISATION
+# ============================================================================
+
+async def exemple_conversation_avec_memoire():
+    """Exemple de conversation avec mémoire (history)."""
+    print("💬 Exemple: Conversation avec mémoire et outils")
+    print("=" * 60)
+    
+    # Créer une histoire de conversation vide
+    history = ConversationHistory()
+    
+    # Question 1: Calcul initial
+    print("\n👤 Client: 'J'ai 50 000€ à placer à 4% par an pendant 10 ans. Combien aurai-je?'")
+    prompt1 = "J'ai 50 000€ à placer à 4% par an pendant 10 ans. Combien aurai-je?"
+    result1 = await finance_advisor.run(prompt1)
+    history.add_user_message(prompt1)
+    history.add_assistant_message(result1.output)
+    print(f"\n🤖 Conseiller:\n{result1.output[:400]}...")
+    
+    # Question 2: Référence au calcul précédent (mémoire via contexte)
+    print("\n" + "-" * 60)
+    print("\n👤 Client: 'Et si j'augmente à 5%?'")
+    # Inclure le contexte précédent dans le prompt
+    context = "\n".join([
+        f"{'👤' if msg['role'] == 'user' else '🤖'} {msg['content'][:200]}..."
+        for msg in history.get_history_for_agent()
+    ])
+    prompt2 = f"Contexte précédent:\n{context}\n\nNouvelle question: Et si j'augmente le taux à 5%?"
+    result2 = await finance_advisor.run(prompt2)
+    history.add_user_message("Et si j'augmente le taux à 5%?")
+    history.add_assistant_message(result2.output)
+    print(f"\n🤖 Conseiller:\n{result2.output[:400]}...")
+    
+    # Question 3: Nouvelle question avec contexte
+    print("\n" + "-" * 60)
+    print("\n👤 Client: 'En fait, je veux plutôt emprunter 200 000€ sur 20 ans à 3.5% pour un achat immobilier'")
+    context = "\n".join([
+        f"{msg['role']}: {msg['content'][:150]}..."
+        for msg in history.get_history_for_agent()[-4:]  # Derniers 4 messages
+    ])
+    prompt3 = f"Contexte:\n{context}\n\nEn fait, je veux plutôt emprunter 200 000€ sur 20 ans à 3.5% pour un achat immobilier. Combien paierai-je par mois?"
+    result3 = await finance_advisor.run(prompt3)
+    history.add_user_message("En fait, je veux plutôt emprunter 200 000€ sur 20 ans à 3.5%")
+    history.add_assistant_message(result3.output)
+    print(f"\n🤖 Conseiller:\n{result3.output[:400]}...")
+    
+    # Afficher l'historique complet
+    print("\n" + "=" * 60)
+    print("📚 Historique de la conversation:")
+    print("=" * 60)
+    for i, msg in enumerate(history.get_history_for_agent(), 1):
+        role = msg['role']
+        content = msg['content'][:100] + "..." if len(msg['content']) > 100 else msg['content']
+        print(f"{i}. {role.upper()}: {content}")
+
+
+async def exemple_portfolio_avec_memoire():
+    """Exemple d'analyse de portfolio avec mémoire des calculs précédents."""
+    print("\n\n📊 Exemple: Analyse de portfolio avec mémoire")
+    print("=" * 60)
+    
+    history = ConversationHistory()
+    
+    # Initialisation du portfolio
+    print("\n👤 Client: 'Mon portfolio valait 100 000€ il y a 6 mois, aujourd'hui il vaut 115 000€'")
+    prompt1 = "Mon portfolio valait 100 000€ il y a 6 mois, aujourd'hui il vaut 115 000€. Calcule la performance."
+    result1 = await finance_advisor.run(prompt1)
+    history.add_user_message(prompt1)
+    history.add_assistant_message(result1.output)
+    print(f"\n🤖 Conseiller:\n{result1.output}")
+    
+    # Suivi avec mémoire
+    print("\n" + "-" * 60)
+    print("\n👤 Client: 'Et si je projette cette performance sur 5 ans?'")
+    context = f"Contexte précédent:\n{result1.output[:300]}...\n\n"
+    prompt2 = context + "Et si je projette cette performance annuelle sur 5 ans avec mon capital actuel de 115 000€?"
+    result2 = await finance_advisor.run(prompt2)
+    history.add_user_message("Et si je projette cette performance sur 5 ans?")
+    history.add_assistant_message(result2.output)
+    print(f"\n🤖 Conseiller:\n{result2.output[:500]}...")
+    
+    return history
+
+
+async def exemple_analyse_complete_avec_memoire():
+    """Exemple complet d'analyse financière avec outils et mémoire."""
+    print("\n\n🎯 Exemple: Analyse financière complète avec mémoire")
+    print("=" * 60)
+    
+    history = ConversationHistory()
+    
+    questions = [
+        "Je gagne 80 000€ par an et j'ai une dette de 200 000€. Quel est mon ratio d'endettement?",
+        "Je veux emprunter 300 000€ pour une résidence principale à 3.5% sur 25 ans. Combien paierai-je?",
+        "Si j'investis les 74 000€ restants après le prêt à 5% par an pendant 15 ans, combien aurai-je?",
+    ]
+    
+    for i, question in enumerate(questions, 1):
+        print(f"\n{'='*60}")
+        print(f"Question {i}: {question}")
+        print("=" * 60)
+        
+        # Inclure le contexte si ce n'est pas la première question
+        if i > 1:
+            context = "\n".join([
+                f"{msg['role']}: {msg['content'][:200]}..."
+                for msg in history.get_history_for_agent()[-2:]  # 2 derniers messages
+            ])
+            full_question = f"Contexte:\n{context}\n\n{question}"
+        else:
+            full_question = question
+        
+        result = await finance_advisor.run(full_question)
+        history.add_user_message(question)
+        history.add_assistant_message(result.output)
+        print(f"\nRéponse:\n{result.output[:600]}...")
+        
+        # Petit délai pour éviter les timeouts
+        await asyncio.sleep(1)
+    
+    print("\n" + "=" * 60)
+    print("✅ Analyse complète terminée!")
+    print(f"📊 Total de messages dans l'historique: {len(history)}")
+
+
+async def exemple_extraction_memoire():
+    """Montre comment extraire des informations de la mémoire."""
+    print("\n\n🔍 Exemple: Extraction d'informations de la mémoire")
+    print("=" * 60)
+    
+    history = ConversationHistory()
+    
+    # Conversation initiale
+    prompt1 = "J'ai un capital de 100 000€ à placer à 4% pendant 10 ans."
+    result1 = await finance_advisor.run(prompt1)
+    history.add_user_message(prompt1)
+    history.add_assistant_message(result1.output)
+    
+    prompt2 = "Je gagne 75 000€ par an et j'ai une dette de 180 000€."
+    result2 = await finance_advisor.run(prompt2)
+    history.add_user_message(prompt2)
+    history.add_assistant_message(result2.output)
+    
+    # Question qui utilise la mémoire
+    print("\n👤 Client: 'Résume ma situation financière'")
+    context = "\n".join([
+        f"{msg['role']}: {msg['content']}"
+        for msg in history.get_history_for_agent()
+    ])
+    result = await finance_advisor.run(
+        f"Contexte de la conversation:\n{context}\n\n"
+        "Peux-tu résumer ma situation financière actuelle basée sur ce que je t'ai dit?"
+    )
+    
+    print(f"\n🤖 Conseiller:\n{result.output}")
+    
+    # Afficher l'historique
+    print("\n" + "-" * 60)
+    print("📚 Messages dans l'historique:")
+    for msg in history.get_history_for_agent():
+        print(f"  {msg['role']}: {msg['content'][:150]}...")
+
+
+if __name__ == "__main__":
+    print("\n" + "=" * 60)
+    print("AGENTS AVEC OUTILS FINANCIERS ET MÉMOIRE")
+    print("=" * 60)
+    
+    # Exemple 1: Conversation avec mémoire
+    asyncio.run(exemple_conversation_avec_memoire())
+    
+    # Exemple 2: Portfolio avec mémoire
+    asyncio.run(exemple_portfolio_avec_memoire())
+    
+    # Exemple 3: Extraction de mémoire
+    asyncio.run(exemple_extraction_memoire())
+    
+    print("\n\n" + "=" * 60)
+    print("✅ Tous les exemples terminés!")
+    print("=" * 60)
+

examples/memory_strategies.py

@@ -0,0 +1,365 @@
+"""
+Stratégies de gestion de mémoire pour agents financiers
+
+Démontre différentes approches pour gérer la mémoire et l'historique
+des conversations avec PydanticAI.
+"""
+
+import asyncio
+from typing import List
+from pydantic_ai import Agent, ModelSettings
+
+from app.models import finance_model
+
+
+# Simple History wrapper
+class ConversationHistory:
+    """Gère l'historique de conversation pour les agents."""
+    
+    def __init__(self):
+        self.messages: List[dict] = []
+    
+    def add_user_message(self, content: str):
+        """Ajoute un message utilisateur."""
+        self.messages.append({"role": "user", "content": content})
+    
+    def add_assistant_message(self, content: str):
+        """Ajoute un message assistant."""
+        self.messages.append({"role": "assistant", "content": content})
+    
+    def get_history_for_agent(self) -> List[dict]:
+        """Retourne l'historique au format pour l'agent."""
+        return self.messages
+    
+    def all_messages(self):
+        """Itérateur sur tous les messages."""
+        return iter(self.messages)
+    
+    def __len__(self):
+        return len(self.messages)
+
+
+# ============================================================================
+# AGENT FINANCIER DE BASE
+# ============================================================================
+
+finance_agent = Agent(
+    finance_model,
+    model_settings=ModelSettings(max_output_tokens=1500),
+    system_prompt=(
+        "Vous êtes un conseiller financier expert. "
+        "Vous gardez en mémoire les informations précédentes de la conversation "
+        "pour fournir des conseils cohérents et personnalisés. "
+        "Répondez toujours en français."
+    ),
+)
+
+
+# ============================================================================
+# STRATÉGIE 1: MÉMOIRE SIMPLE (HISTORY)
+# ============================================================================
+
+async def strategie_memoire_simple():
+    """Mémoire basique avec History - tout est conservé."""
+    print("📝 Stratégie 1: Mémoire simple (tout est conservé)")
+    print("=" * 60)
+    
+    history = ConversationHistory()
+    
+    # Conversation
+    result1 = await finance_agent.run("J'ai 100 000€ à investir.")
+    history.add_user_message("J'ai 100 000€ à investir.")
+    history.add_assistant_message(result1.output)
+    
+    result2 = await finance_agent.run("Mon objectif est la retraite dans 20 ans.")
+    history.add_user_message("Mon objectif est la retraite dans 20 ans.")
+    history.add_assistant_message(result2.output)
+    
+    # Question qui nécessite la mémoire
+    context = "\n".join([f"{msg['role']}: {msg['content'][:200]}" for msg in history.get_history_for_agent()])
+    result = await finance_agent.run(
+        f"Contexte:\n{context}\n\nQuel type d'investissement me recommandes-tu?"
+    )
+    
+    print(f"\nRéponse:\n{result.output[:400]}...")
+    print(f"\n📊 Messages dans l'historique: {len(history)}")
+
+
+# ============================================================================
+# STRATÉGIE 2: MÉMOIRE SÉLECTIVE (FILTRAGE)
+# ============================================================================
+
+class SelectiveMemory:
+    """Mémoire sélective qui ne garde que les informations importantes."""
+    
+    def __init__(self):
+        self.history = History()
+        self.important_facts = []
+    
+    def add_fact(self, fact: str):
+        """Ajoute un fait important à retenir."""
+        self.important_facts.append(fact)
+    
+    def get_context(self) -> str:
+        """Retourne le contexte des faits importants."""
+        if not self.important_facts:
+            return ""
+        return "Faits importants à retenir:\n" + "\n".join(f"- {f}" for f in self.important_facts)
+
+
+async def strategie_memoire_selective():
+    """Mémoire sélective - on garde seulement les faits clés."""
+    print("\n\n🎯 Stratégie 2: Mémoire sélective (faits clés)")
+    print("=" * 60)
+    
+    memory = SelectiveMemory()
+    history = ConversationHistory()
+    
+    # Conversation avec extraction de faits
+    prompt = "J'ai 100 000€ à investir pour la retraite dans 20 ans. J'ai 45 ans."
+    result1 = await finance_agent.run(prompt)
+    history.add_user_message(prompt)
+    history.add_assistant_message(result1.output)
+    memory.add_fact("Capital: 100 000€")
+    memory.add_fact("Objectif: Retraite")
+    memory.add_fact("Horizon: 20 ans")
+    memory.add_fact("Âge: 45 ans")
+    
+    print(f"\n📌 Faits extraits: {memory.important_facts}")
+    
+    # Nouvelle question avec contexte des faits
+    context = memory.get_context()
+    result2 = await finance_agent.run(
+        f"{context}\n\nQuestion: Quel type d'investissement me recommandes-tu?"
+    )
+    
+    print(f"\nRéponse:\n{result2.output[:400]}...")
+
+
+# ============================================================================
+# STRATÉGIE 3: MÉMOIRE STRUCTURÉE (PROFIL CLIENT)
+# ============================================================================
+
+class ClientProfile:
+    """Profil structuré du client."""
+    
+    def __init__(self):
+        self.age: int | None = None
+        self.revenus_annuels: float | None = None
+        self.capital: float | None = None
+        self.objectifs: list[str] = []
+        self.horizon: int | None = None
+        self.profil_risque: str | None = None
+    
+    def to_context(self) -> str:
+        """Convertit le profil en contexte pour l'agent."""
+        parts = ["Profil client:"]
+        if self.age:
+            parts.append(f"- Âge: {self.age} ans")
+        if self.revenus_annuels:
+            parts.append(f"- Revenus annuels: {self.revenus_annuels:,.0f}€")
+        if self.capital:
+            parts.append(f"- Capital: {self.capital:,.0f}€")
+        if self.objectifs:
+            parts.append(f"- Objectifs: {', '.join(self.objectifs)}")
+        if self.horizon:
+            parts.append(f"- Horizon: {self.horizon} ans")
+        if self.profil_risque:
+            parts.append(f"- Profil de risque: {self.profil_risque}")
+        return "\n".join(parts)
+
+
+async def strategie_memoire_structuree():
+    """Mémoire structurée avec profil client."""
+    print("\n\n📋 Stratégie 3: Mémoire structurée (profil client)")
+    print("=" * 60)
+    
+    profile = ClientProfile()
+    history = ConversationHistory()
+    
+    # Construction du profil
+    prompt = "J'ai 45 ans, je gagne 80 000€ par an et j'ai 150 000€ d'épargne. Je veux préparer ma retraite dans 20 ans avec un profil modéré."
+    result1 = await finance_agent.run(prompt)
+    history.add_user_message(prompt)
+    history.add_assistant_message(result1.output)
+    
+    # Extraction structurée (ici simplifiée, idéalement avec output_type)
+    profile.age = 45
+    profile.revenus_annuels = 80000
+    profile.capital = 150000
+    profile.objectifs = ["Retraite"]
+    profile.horizon = 20
+    profile.profil_risque = "Modéré"
+    
+    print(f"\n📋 Profil client construit:\n{profile.to_context()}")
+    
+    # Utilisation du profil dans les conseils
+    context = profile.to_context()
+    result2 = await finance_agent.run(
+        f"{context}\n\nQuelle stratégie d'investissement me recommandes-tu?"
+    )
+    
+    print(f"\nRéponse:\n{result2.output[:500]}...")
+
+
+# ============================================================================
+# STRATÉGIE 4: MÉMOIRE AVEC RÉSUMÉ (COMPRESSION)
+# ============================================================================
+
+async def strategie_memoire_avec_resume():
+    """Mémoire avec résumé périodique pour éviter la surcharge."""
+    print("\n\n📄 Stratégie 4: Mémoire avec résumé (compression)")
+    print("=" * 60)
+    
+    history = ConversationHistory()
+    
+    # Conversation longue
+    messages = [
+        "J'ai 45 ans et je gagne 80 000€ par an.",
+        "J'ai 150 000€ d'épargne actuellement.",
+        "Mon objectif est la retraite dans 20 ans.",
+        "J'ai un profil de risque modéré.",
+        "Je préfère les investissements diversifiés.",
+    ]
+    
+    for msg in messages:
+        result = await finance_agent.run(msg)
+        history.add_user_message(msg)
+        history.add_assistant_message(result.output)
+        print(f"  ✓ Ajouté: {msg}")
+    
+    # Créer un résumé quand l'historique devient long
+    if len(history) > 6:
+        print("\n📝 Création d'un résumé de conversation...")
+        context = "\n".join([f"{msg['role']}: {msg['content']}" for msg in history.get_history_for_agent()])
+        summary_result = await finance_agent.run(
+            f"Contexte:\n{context}\n\n"
+            "Résume en 3-4 phrases les informations clés que le client t'a données "
+            "dans cette conversation pour créer un profil client."
+        )
+        print(f"\n📄 Résumé:\n{summary_result.output[:300]}...")
+        
+        # Utiliser le résumé comme nouveau contexte
+        summary_context = summary_result.output
+        result = await finance_agent.run(
+            f"Contexte client:\n{summary_context}\n\n"
+            "Quelle stratégie d'investissement recommandes-tu?"
+        )
+        print(f"\n💡 Recommandation basée sur le résumé:\n{result.output[:400]}...")
+
+
+# ============================================================================
+# STRATÉGIE 5: MÉMOIRE MULTI-SESSION (PERSISTANCE)
+# ============================================================================
+
+import json
+from datetime import datetime
+
+
+class PersistentMemory:
+    """Mémoire persistante qui peut être sauvegardée/chargée."""
+    
+    def __init__(self, client_id: str):
+        self.client_id = client_id
+        self.history = History()
+        self.facts = {}
+        self.last_interaction = None
+    
+    def save(self, filepath: str):
+        """Sauvegarde la mémoire dans un fichier."""
+        data = {
+            "client_id": self.client_id,
+            "facts": self.facts,
+            "last_interaction": self.last_interaction.isoformat() if self.last_interaction else None,
+            "messages": [
+                {"role": msg.role, "content": msg.content}
+                for msg in self.history.all_messages()
+            ],
+        }
+        with open(filepath, "w") as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+    
+    @classmethod
+    def load(cls, filepath: str):
+        """Charge la mémoire depuis un fichier."""
+        with open(filepath, "r") as f:
+            data = json.load(f)
+        
+        memory = cls(data["client_id"])
+        memory.facts = data.get("facts", {})
+        if data.get("last_interaction"):
+            memory.last_interaction = datetime.fromisoformat(data["last_interaction"])
+        
+        # Reconstruire l'historique (simplifié)
+        for msg_data in data.get("messages", []):
+            # Note: Cette reconstruction est simplifiée
+            # En production, utilisez l'API History correctement
+            pass
+        
+        return memory
+
+
+async def strategie_memoire_persistante():
+    """Mémoire persistante entre sessions."""
+    print("\n\n💾 Stratégie 5: Mémoire persistante (multi-session)")
+    print("=" * 60)
+    
+    # Session 1
+    memory = PersistentMemory("client_001")
+    memory.facts = {
+        "age": 45,
+        "revenus": 80000,
+        "capital": 150000,
+        "objectif": "Retraite",
+    }
+    memory.last_interaction = datetime.now()
+    
+    # Sauvegarder
+    filepath = "/tmp/client_memory.json"
+    memory.save(filepath)
+    print(f"✅ Mémoire sauvegardée: {filepath}")
+    
+    # Simuler une nouvelle session (chargement)
+    print("\n🔄 Nouvelle session - Chargement de la mémoire...")
+    loaded_memory = PersistentMemory.load(filepath)
+    
+    print(f"📋 Faits chargés: {loaded_memory.facts}")
+    print(f"🕐 Dernière interaction: {loaded_memory.last_interaction}")
+    
+    # Utiliser la mémoire chargée
+    context = "Contexte client:\n" + "\n".join(
+        f"- {k}: {v}" for k, v in loaded_memory.facts.items()
+    )
+    
+    result = await finance_agent.run(
+        f"{context}\n\nJe reviens vous voir 6 mois plus tard. Mon capital est maintenant de 160 000€. "
+        "Quelle est ma nouvelle situation?"
+    )
+    
+    print(f"\nRéponse:\n{result.output[:400]}...")
+
+
+if __name__ == "__main__":
+    print("\n" + "=" * 60)
+    print("STRATÉGIES DE GESTION DE MÉMOIRE POUR AGENTS")
+    print("=" * 60)
+    
+    # Stratégie 1
+    asyncio.run(strategie_memoire_simple())
+    
+    # Stratégie 2
+    asyncio.run(strategie_memoire_selective())
+    
+    # Stratégie 3
+    asyncio.run(strategie_memoire_structuree())
+    
+    # Stratégie 4
+    asyncio.run(strategie_memoire_avec_resume())
+    
+    # Stratégie 5
+    asyncio.run(strategie_memoire_persistante())
+    
+    print("\n\n" + "=" * 60)
+    print("✅ Toutes les stratégies démontrées!")
+    print("=" * 60)
+

examples/swift_extractor.py

@@ -0,0 +1,336 @@
+"""
+Module d'extraction avancée de messages SWIFT avec validation Pydantic.
+
+Fournit des fonctions robustes pour parser et valider les messages SWIFT,
+avec support des champs multi-lignes et validation stricte des formats.
+"""
+
+import re
+from typing import Optional
+from pydantic import BaseModel, Field, field_validator, ValidationError
+
+
+class SwiftField32A(BaseModel):
+    """Représente le champ :32A: (Date de valeur, devise, montant)."""
+    value_date: str = Field(description="Date YYYYMMDD")
+    currency: str = Field(description="Code devise ISO 3 lettres")
+    amount: float = Field(description="Montant", gt=0)
+    
+    @field_validator("value_date")
+    @classmethod
+    def validate_date(cls, v: str) -> str:
+        if len(v) != 8 or not v.isdigit():
+            raise ValueError(f"Date must be YYYYMMDD format, got: {v}")
+        # Valider que c'est une date valide
+        year = int(v[:4])
+        month = int(v[4:6])
+        day = int(v[6:8])
+        if not (1900 <= year <= 2100 and 1 <= month <= 12 and 1 <= day <= 31):
+            raise ValueError(f"Invalid date values: {v}")
+        return v
+    
+    @field_validator("currency")
+    @classmethod
+    def validate_currency(cls, v: str) -> str:
+        if len(v) != 3 or not v.isalpha():
+            raise ValueError(f"Currency must be 3 letter ISO code, got: {v}")
+        return v.upper()
+
+
+class SwiftMT103Parsed(BaseModel):
+    """Structure complète d'un message SWIFT MT103 parsé et validé."""
+    
+    # Champs obligatoires
+    field_20: str = Field(description=":20: Référence du transfert")
+    field_32A: SwiftField32A = Field(description=":32A: Date, devise, montant")
+    field_50K: str = Field(description=":50K: Ordre donneur")
+    field_59: str = Field(description=":59: Bénéficiaire")
+    
+    # Champs optionnels avec valeurs par défaut
+    field_23B: str = Field(default="CRED", description=":23B: Code instruction")
+    field_52A: Optional[str] = Field(default=None, description=":52A: BIC banque ordonnateur")
+    field_56A: Optional[str] = Field(default=None, description=":56A: BIC banque intermédiaire")
+    field_57A: Optional[str] = Field(default=None, description=":57A: BIC banque bénéficiaire")
+    field_70: Optional[str] = Field(default=None, description=":70: Information pour bénéficiaire")
+    field_71A: str = Field(default="OUR", description=":71A: Frais (OUR/SHA/BEN)")
+    field_72: Optional[str] = Field(default=None, description=":72: Information banque à banque")
+    
+    # Champs extraits (IBAN, noms, etc.)
+    ordering_customer_account: Optional[str] = Field(default=None, description="IBAN ordonnateur extrait")
+    beneficiary_account: Optional[str] = Field(default=None, description="IBAN bénéficiaire extrait")
+    
+    @field_validator("field_71A")
+    @classmethod
+    def validate_charges(cls, v: str) -> str:
+        valid = ["OUR", "SHA", "BEN"]
+        if v not in valid:
+            raise ValueError(f"Charges must be one of {valid}, got: {v}")
+        return v
+    
+    @field_validator("field_52A", "field_56A", "field_57A")
+    @classmethod
+    def validate_bic(cls, v: Optional[str]) -> Optional[str]:
+        if v is None:
+            return v
+        v = v.strip()[:11]  # BIC max 11 caractères
+        if len(v) not in [8, 11]:
+            raise ValueError(f"BIC must be 8 or 11 characters, got: {len(v)}")
+        return v
+
+
+def extract_iban_from_text(text: str) -> Optional[str]:
+    """Extrait un IBAN depuis un texte (format: 2 lettres + 2 chiffres + 12-34 caractères)."""
+    # Pattern IBAN: 2 lettres pays + 2 chiffres + 12-34 alphanumériques
+    # Les IBAN ont une longueur fixe par pays, mais on accepte 15-34 caractères
+    pattern = r'([A-Z]{2}\d{2}[A-Z0-9\s]{12,30})'
+    matches = re.finditer(pattern, text)
+    
+    for match in matches:
+        iban_candidate = match.group(1).replace(" ", "").replace("\n", "")
+        
+        # Vérifier la longueur
+        if not (15 <= len(iban_candidate) <= 34):
+            continue
+        
+        # Vérifier qu'on n'a pas capturé du texte après l'IBAN
+        # Les IBAN se terminent typiquement avant un mot (lettre minuscule après majuscules/chiffres)
+        start_pos = match.start()
+        end_pos = match.end()
+        
+        # Si on commence par "/" ou après un "/", c'est probablement un IBAN
+        if start_pos > 0 and text[start_pos - 1] == "/":
+            # Couper au premier caractère non-alphanumérique ou après 34 caractères max
+            iban_clean = iban_candidate[:34] if len(iban_candidate) > 34 else iban_candidate
+            # Si on a capturé trop, chercher une coupure naturelle
+            if len(iban_clean) > 20:  # La plupart des IBAN font 27 caractères
+                # Tronquer à une longueur raisonnable (IBAN max = 34)
+                iban_clean = iban_clean[:34]
+            return iban_clean
+        
+        # Vérifier les caractères après la match
+        if end_pos < len(text):
+            next_char = text[end_pos]
+            # Si le caractère suivant est une lettre minuscule, on a probablement capturé trop
+            if next_char.islower():
+                continue
+        
+        return iban_candidate[:34] if len(iban_candidate) > 34 else iban_candidate
+    
+    return None
+
+
+def extract_bic_from_text(text: str) -> Optional[str]:
+    """Extrait un BIC depuis un texte (8 ou 11 caractères alphanumériques)."""
+    # Pattern BIC: 4 lettres + 2 lettres + 2 caractères (optionnel: 3 caractères)
+    pattern = r'\b([A-Z]{4}[A-Z]{2}[A-Z0-9]{2}([A-Z0-9]{3})?)\b'
+    matches = re.findall(pattern, text)
+    if matches:
+        return matches[0][0]  # Retourner le BIC complet
+    return None
+
+
+def parse_swift_field_32a(value: str) -> SwiftField32A:
+    """
+    Parse le champ :32A: (format: YYMMDD ou YYYYMMDD + 3 lettres + montant).
+    
+    Formats supportés:
+    - YYMMDD + currency + amount (ex: 241215EUR15000.00)
+    - YYYYMMDD + currency + amount (ex: 20241215EUR15000.00)
+    """
+    value = value.strip()
+    
+    # Déterminer si c'est un format à 6 chiffres (YYMMDD) ou 8 chiffres (YYYYMMDD)
+    # On cherche le début de la devise (3 lettres majuscules)
+    currency_match = re.search(r'([A-Z]{3})', value[6:])  # Chercher après les 6 premiers chiffres
+    
+    if not currency_match:
+        raise ValueError(f"Cannot find currency code in :32A: {value}")
+    
+    currency_start = currency_match.start() + 6  # Position de début de la devise
+    date_str = value[:currency_start]
+    currency_str = currency_match.group(1)
+    amount_str = value[currency_start + 3:].strip()  # Ne pas remplacer les virgules ici
+    
+    # Convertir YYMMDD en YYYYMMDD si nécessaire
+    if len(date_str) == 6:
+        # Format YYMMDD - convertir en YYYYMMDD
+        year = int(date_str[:2])
+        # Supposer années 2000-2099 si YY < 50, sinon 1900-1999
+        full_year = 2000 + year if year < 50 else 1900 + year
+        date_str = f"{full_year}{date_str[2:]}"
+    elif len(date_str) != 8:
+        raise ValueError(f"Date must be 6 (YYMMDD) or 8 (YYYYMMDD) digits, got: {date_str} (length {len(date_str)})")
+    
+    if not amount_str:
+        raise ValueError(f"Missing amount in :32A: {value}")
+    
+    # Gérer les formats de montants variés
+    # Format européen: 1.234,56 (point pour milliers, virgule pour décimales)
+    # Format anglais: 1,234.56 (virgule pour milliers, point pour décimales)
+    # Format simple: 1234.56 ou 1234,56
+    
+    # Détecter le format
+    has_comma = "," in amount_str
+    has_dot = "." in amount_str
+    
+    if has_comma and has_dot:
+        # Déterminer lequel est le séparateur de décimales
+        comma_pos = amount_str.rfind(",")
+        dot_pos = amount_str.rfind(".")
+        
+        if comma_pos > dot_pos:
+            # Format européen: 1.234,56 → 1234.56
+            amount_str = amount_str.replace(".", "").replace(",", ".")
+        else:
+            # Format anglais: 1,234.56 → 1234.56
+            amount_str = amount_str.replace(",", "")
+    elif has_comma and not has_dot:
+        # Format européen sans milliers: 1234,56 → 1234.56
+        amount_str = amount_str.replace(",", ".")
+    
+    try:
+        amount = float(amount_str)
+    except ValueError:
+        raise ValueError(f"Invalid amount format in :32A: {amount_str}")
+    
+    return SwiftField32A(
+        value_date=date_str,
+        currency=currency_str,
+        amount=amount
+    )
+
+
+def parse_swift_mt103_advanced(swift_text: str) -> SwiftMT103Parsed:
+    """
+    Parse un message SWIFT MT103 avec validation complète.
+    
+    Gère:
+    - Tous les champs standard MT103
+    - Champs multi-lignes
+    - Extraction automatique d'IBAN et BIC
+    - Validation stricte avec Pydantic
+    """
+    lines = [line.rstrip() for line in swift_text.split("\n")]
+    
+    data = {}
+    i = 0
+    
+    while i < len(lines):
+        line = lines[i].strip()
+        if not line:
+            i += 1
+            continue
+        
+        # Pattern pour identifier les tags SWIFT (format :XX: ou :XXA:, :XXB:, etc.)
+        tag_match = re.match(r'^:(\d{2}[A-Z]?):', line)
+        if not tag_match:
+            i += 1
+            continue
+        
+        tag = tag_match.group(0)  # e.g. ":20:", ":32A:"
+        tag_num = tag_match.group(1)  # e.g. "20", "32A"
+        content_start = len(tag)
+        
+        # Extraire le contenu (peut être multi-lignes)
+        content_lines = []
+        current_line = line[content_start:].strip()
+        if current_line:
+            content_lines.append(current_line)
+        
+        # Lire les lignes suivantes jusqu'au prochain tag ou fin
+        i += 1
+        while i < len(lines):
+            next_line = lines[i].strip()
+            if next_line.startswith(":"):
+                break
+            if next_line:
+                content_lines.append(next_line)
+            i += 1
+        
+        full_content = "\n".join(content_lines)
+        
+        # Traitement selon le tag
+        if tag_num == "20":
+            data["field_20"] = full_content or "NONREF"
+        
+        elif tag_num == "23B":
+            data["field_23B"] = full_content or "CRED"
+        
+        elif tag_num == "32A":
+            data["field_32A"] = parse_swift_field_32a(full_content)
+        
+        elif tag_num.startswith("50"):
+            data["field_50K"] = full_content
+            # Extraire IBAN si présent
+            iban = extract_iban_from_text(full_content)
+            if iban:
+                data["ordering_customer_account"] = iban
+        
+        elif tag_num == "52A":
+            bic = extract_bic_from_text(full_content) or full_content[:11]
+            data["field_52A"] = bic
+        
+        elif tag_num == "56A":
+            bic = extract_bic_from_text(full_content) or full_content[:11]
+            data["field_56A"] = bic
+        
+        elif tag_num == "57A":
+            bic = extract_bic_from_text(full_content) or full_content[:11]
+            data["field_57A"] = bic
+        
+        elif tag_num.startswith("59"):
+            data["field_59"] = full_content
+            # Extraire IBAN si présent
+            iban = extract_iban_from_text(full_content)
+            if iban:
+                data["beneficiary_account"] = iban
+        
+        elif tag_num == "70":
+            data["field_70"] = full_content
+        
+        elif tag_num == "71A":
+            data["field_71A"] = full_content.strip() or "OUR"
+        
+        elif tag_num == "72":
+            data["field_72"] = full_content
+        
+        # Ne pas incrémenter i ici car on l'a déjà fait dans la boucle while
+    
+    # Validation avec Pydantic
+    try:
+        return SwiftMT103Parsed(**data)
+    except ValidationError as e:
+        raise ValueError(f"Validation error: {e}") from e
+
+
+def format_swift_mt103_from_parsed(parsed: SwiftMT103Parsed) -> str:
+    """Reformate un message SWIFT MT103 depuis une structure parsée."""
+    lines = [
+        f":20:{parsed.field_20}",
+        f":23B:{parsed.field_23B}",
+        f":32A:{parsed.field_32A.value_date}{parsed.field_32A.currency}{parsed.field_32A.amount:.2f}",
+    ]
+    
+    if parsed.field_52A:
+        lines.append(f":52A:{parsed.field_52A}")
+    
+    lines.append(f":50K:/{parsed.field_50K}")
+    
+    if parsed.field_56A:
+        lines.append(f":56A:{parsed.field_56A}")
+    
+    if parsed.field_57A:
+        lines.append(f":57A:{parsed.field_57A}")
+    
+    lines.append(f":59:/{parsed.field_59}")
+    
+    if parsed.field_70:
+        lines.append(f":70:{parsed.field_70}")
+    
+    lines.append(f":71A:{parsed.field_71A}")
+    
+    if parsed.field_72:
+        lines.append(f":72:{parsed.field_72}")
+    
+    return "\n".join(lines)
+

examples/swift_models.py

@@ -0,0 +1,106 @@
+"""
+Modèles Pydantic pour messages SWIFT.
+
+Ces modèles peuvent être utilisés avec output_type pour valider
+automatiquement la structure des messages SWIFT générés.
+"""
+
+from pydantic import BaseModel, Field, field_validator
+from datetime import datetime
+
+
+class SWIFTFielBase(BaseModel):
+    """Classe de base pour les champs SWIFT."""
+    pass
+
+
+class MT103Field32A(BaseModel):
+    """Champ :32A: Date de valeur, devise, montant."""
+    value_date: str = Field(description="Date de valeur YYYYMMDD")
+    currency: str = Field(description="Code devise ISO 3 lettres")
+    amount: float = Field(description="Montant", gt=0)
+    
+    @field_validator("value_date")
+    def validate_date(cls, v):
+        if len(v) != 8 or not v.isdigit():
+            raise ValueError("Date must be YYYYMMDD format")
+        try:
+            datetime.strptime(v, "%Y%m%d")
+        except ValueError:
+            raise ValueError("Invalid date")
+        return v
+    
+    @field_validator("currency")
+    def validate_currency(cls, v):
+        if len(v) != 3 or not v.isalpha():
+            raise ValueError("Currency must be 3 letter ISO code")
+        return v.upper()
+
+
+class SWIFTMT103Structured(BaseModel):
+    """Message SWIFT MT103 avec validation complète."""
+    
+    field_20: str = Field(description=":20: Référence du transfert")
+    field_23B: str = Field(default="CRED", description=":23B: Code instruction")
+    field_32A: MT103Field32A = Field(description=":32A: Date, devise, montant")
+    field_50K: str = Field(description=":50K: Ordre donneur")
+    field_59: str = Field(description=":59: Bénéficiaire")
+    field_70: str | None = Field(default=None, description=":70: Information pour bénéficiaire")
+    field_71A: str = Field(default="OUR", description=":71A: Frais (OUR/SHA/BEN)")
+    
+    @field_validator("field_71A")
+    def validate_charges(cls, v):
+        valid = ["OUR", "SHA", "BEN"]
+        if v not in valid:
+            raise ValueError(f"Charges must be one of {valid}")
+        return v
+    
+    def to_swift_format(self) -> str:
+        """Convertit en format SWIFT standard."""
+        lines = [
+            f":20:{self.field_20}",
+            f":23B:{self.field_23B}",
+            f":32A:{self.field_32A.value_date}{self.field_32A.currency}{self.field_32A.amount:.2f}",
+            f":50K:/{self.field_50K}",
+            f":59:/{self.field_59}",
+        ]
+        
+        if self.field_70:
+            lines.append(f":70:{self.field_70}")
+        
+        lines.append(f":71A:{self.field_71A}")
+        
+        return "\n".join(lines)
+
+
+# Exemple d'utilisation avec validation
+def example_with_validation():
+    """Exemple d'utilisation avec validation Pydantic."""
+    try:
+        mt103 = SWIFTMT103Structured(
+            field_20="TXN-2025-001",
+            field_32A=MT103Field32A(
+                value_date="20250120",
+                currency="EUR",
+                amount=15000.00
+            ),
+            field_50K="FR76300040000100000000000123\nORDRE DUPONT",
+            field_59="FR1420041010050500013M02606\nBENEFICIAIRE MARTIN",
+            field_70="Paiement facture",
+            field_71A="OUR"
+        )
+        
+        print("✅ Message SWIFT validé:")
+        print(mt103.to_swift_format())
+        
+    except Exception as e:
+        print(f"❌ Erreur de validation: {e}")
+
+
+
+
+
+
+
+
+

examples/test_swift_parsing.py

@@ -0,0 +1,355 @@
+"""
+Jeu de tests pour vérifier le parsing de messages SWIFT.
+
+Teste différents formats et cas limites pour s'assurer que l'extraction
+fonctionne correctement avec validation Pydantic.
+"""
+
+import sys
+from pathlib import Path
+
+# Ajouter le répertoire au path pour les imports
+sys.path.insert(0, str(Path(__file__).parent))
+
+from swift_extractor import (
+    parse_swift_mt103_advanced,
+    SwiftMT103Parsed,
+    extract_iban_from_text,
+    extract_bic_from_text,
+    parse_swift_field_32a,
+)
+
+
+# ============================================================================
+# MESSAGES SWIFT DE TEST
+# ============================================================================
+
+TEST_MESSAGE_1_SIMPLE = """
+:20:NONREF
+:23B:CRED
+:32A:241215EUR15000.00
+:50K:/FR76300040000100000000000123
+ORDRE DUPONT JEAN
+:59:/FR1420041010050500013M02606
+BENEFICIAIRE MARTIN PIERRE
+:70:Paiement facture décembre 2024
+:71A:OUR
+"""
+
+TEST_MESSAGE_2_FULL_DATE = """
+:20:INVOICE-2024-001
+:23B:CRED
+:32A:20241215EUR25000.50
+:50K:/FR76300040000100000000000123
+ORDRE DUPONT JEAN
+RUE DE LA REPUBLIQUE 123
+75001 PARIS FRANCE
+:52A:BNPAFRPPXXX
+:56A:SOGEFRPPXXX
+:57A:CRLYFRPPXXX
+:59:/FR1420041010050500013M02606
+BENEFICIAIRE MARTIN PIERRE
+AVENUE DES CHAMPS ELYSEES 456
+75008 PARIS FRANCE
+:70:Paiement facture décembre 2024
+Référence: INV-001
+:71A:SHA
+:72:/INS/BANQUE INTERMEDIAIRE
+"""
+
+TEST_MESSAGE_3_MULTILINE = """
+:20:TXN-2025-001
+:23B:CRED
+:32A:250120USD50000.00
+:50K:/US64SVBKUS6SXXX123456789
+COMPANY ABC INC
+123 MAIN STREET
+NEW YORK NY 10001
+UNITED STATES
+:52A:ABCDUS33XXX
+:59:/GB82WEST12345698765432
+BENEFICIARY XYZ LTD
+456 HIGH STREET
+LONDON EC1A 1BB
+UNITED KINGDOM
+:70:Payment for services Q1 2025
+Contract reference: CONTRACT-2025-001
+Invoice: INV-2025-042
+:71A:BEN
+:72:/INS/Urgent payment requested
+"""
+
+TEST_MESSAGE_4_EUROPEAN = """
+:20:PAY-2024-042
+:23B:CRED
+:32A:241231CHF125000.00
+:50K:/CH9300762011623852957
+SWISS COMPANY AG
+BAHNHOFSTRASSE 1
+8001 ZURICH
+SWITZERLAND
+:52A:UBSWCHZH80A
+:57A:DEUTDEFFXXX
+:59:/DE89370400440532013000
+GERMAN BENEFICIARY GMBH
+FRIEDRICHSTRASSE 100
+10117 BERLIN
+GERMANY
+:70:Year-end payment 2024
+:71A:OUR
+:72:/INS/Final payment of the year
+"""
+
+TEST_MESSAGE_5_MINIMAL = """
+:20:MIN-REF-001
+:23B:CRED
+:32A:250101EUR100.00
+:50K:/FR76300040000100000000000123
+CUSTOMER NAME
+:59:/FR1420041010050500013M02606
+BENEFICIARY NAME
+:71A:OUR
+"""
+
+TEST_MESSAGE_6_WITH_COMMA_ENGLISH = """
+:20:REF-COMMA-ENG
+:23B:CRED
+:32A:250101EUR1,234.56
+:50K:/FR76300040000100000000000123
+ORDERING CUSTOMER
+:59:/FR1420041010050500013M02606
+BENEFICIARY CUSTOMER
+:70:Test with comma as thousands separator (English format)
+:71A:OUR
+"""
+
+TEST_MESSAGE_6_WITH_COMMA_EUROPEAN = """
+:20:REF-COMMA-EUR
+:23B:CRED
+:32A:250101EUR1.234,56
+:50K:/FR76300040000100000000000123
+ORDERING CUSTOMER
+:59:/FR1420041010050500013M02606
+BENEFICIARY CUSTOMER
+:70:Test with dot for thousands and comma for decimals (European format)
+:71A:OUR
+"""
+
+TEST_MESSAGE_7_INTERNATIONAL = """
+:20:INTL-TXN-001
+:23B:CRED
+:32A:250215JPY1000000.00
+:50K:/JP9123456789012345678901
+JAPANESE COMPANY CO LTD
+TOKYO 100-0001
+JAPAN
+:52A:MHCBJPJTXXX
+:56A:CHASUS33XXX
+:57A:HSBCGB2LXXX
+:59:/GB29NWBK60161331926819
+UK BENEFICIARY LTD
+LONDON
+:70:International transfer
+:71A:SHA
+:72:/INS/Correspondent bank details
+"""
+
+
+# ============================================================================
+# TESTS
+# ============================================================================
+
+def test_field_32a_parsing():
+    """Test le parsing du champ :32A: avec différents formats."""
+    print("\n" + "=" * 60)
+    print("TEST: Parsing champ :32A:")
+    print("=" * 60)
+    
+    test_cases = [
+        ("241215EUR15000.00", "2024-12-15", "EUR", 15000.0),  # YYMMDD
+        ("20241215EUR15000.00", "2024-12-15", "EUR", 15000.0),  # YYYYMMDD
+        ("250101USD100.50", "2025-01-01", "USD", 100.5),  # Format court
+        ("991231GBP5000.00", "1999-12-31", "GBP", 5000.0),  # Année 99 → 1999
+    ]
+    
+    for value, expected_date, expected_currency, expected_amount in test_cases:
+        try:
+            parsed = parse_swift_field_32a(value)
+            assert parsed.value_date == expected_date.replace("-", ""), \
+                f"Date mismatch: {parsed.value_date} != {expected_date}"
+            assert parsed.currency == expected_currency, \
+                f"Currency mismatch: {parsed.currency} != {expected_currency}"
+            assert parsed.amount == expected_amount, \
+                f"Amount mismatch: {parsed.amount} != {expected_amount}"
+            print(f"✅ {value} → {parsed.value_date} {parsed.currency} {parsed.amount}")
+        except Exception as e:
+            print(f"❌ {value} → ERREUR: {e}")
+
+
+def test_iban_extraction():
+    """Test l'extraction d'IBAN depuis du texte."""
+    print("\n" + "=" * 60)
+    print("TEST: Extraction IBAN")
+    print("=" * 60)
+    
+    test_cases = [
+        ("/FR76 3000 4000 0100 0000 0000 123", "FR76300040000100000000000123"),
+        ("FR1420041010050500013M02606", "FR1420041010050500013M02606"),
+        ("Compte: GB82WEST12345698765432", "GB82WEST12345698765432"),
+        ("IBAN: CH9300762011623852957 dans le texte", "CH9300762011623852957"),
+    ]
+    
+    for text, expected in test_cases:
+        iban = extract_iban_from_text(text)
+        if iban == expected:
+            print(f"✅ '{text[:40]}...' → {iban}")
+        else:
+            print(f"❌ '{text[:40]}...' → {iban} (attendu: {expected})")
+
+
+def test_bic_extraction():
+    """Test l'extraction de BIC depuis du texte."""
+    print("\n" + "=" * 60)
+    print("TEST: Extraction BIC")
+    print("=" * 60)
+    
+    test_cases = [
+        ("BNPAFRPPXXX", "BNPAFRPPXXX"),
+        ("BIC: SOGEFRPPXXX", "SOGEFRPPXXX"),
+        ("Bank: ABCDUS33", "ABCDUS33"),
+        ("BIC ABCDUS33XXX in text", "ABCDUS33XXX"),
+    ]
+    
+    for text, expected in test_cases:
+        bic = extract_bic_from_text(text)
+        if bic == expected:
+            print(f"✅ '{text}' → {bic}")
+        else:
+            print(f"❌ '{text}' → {bic} (attendu: {expected})")
+
+
+def test_swift_parsing(message_name: str, message: str, description: str = ""):
+    """Test le parsing d'un message SWIFT complet."""
+    print(f"\n{'=' * 60}")
+    print(f"TEST: {message_name}")
+    if description:
+        print(f"Description: {description}")
+    print("=" * 60)
+    
+    try:
+        parsed = parse_swift_mt103_advanced(message)
+        
+        print(f"✅ Parsing réussi!")
+        print(f"  Référence: {parsed.field_20}")
+        print(f"  Date: {parsed.field_32A.value_date}")
+        print(f"  Devise: {parsed.field_32A.currency}")
+        print(f"  Montant: {parsed.field_32A.amount:,.2f} {parsed.field_32A.currency}")
+        
+        if parsed.ordering_customer_account:
+            print(f"  IBAN ordonnateur: {parsed.ordering_customer_account}")
+        if parsed.beneficiary_account:
+            print(f"  IBAN bénéficiaire: {parsed.beneficiary_account}")
+        if parsed.field_52A:
+            print(f"  BIC banque ordonnateur: {parsed.field_52A}")
+        if parsed.field_56A:
+            print(f"  BIC banque intermédiaire: {parsed.field_56A}")
+        if parsed.field_57A:
+            print(f"  BIC banque bénéficiaire: {parsed.field_57A}")
+        if parsed.field_70:
+            print(f"  Motif: {parsed.field_70[:50]}...")
+        print(f"  Frais: {parsed.field_71A}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ ERREUR: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+
+def run_all_tests():
+    """Exécute tous les tests."""
+    print("\n" + "=" * 60)
+    print("SUITE DE TESTS - PARSING SWIFT")
+    print("=" * 60)
+    
+    results = []
+    
+    # Tests unitaires
+    test_field_32a_parsing()
+    test_iban_extraction()
+    test_bic_extraction()
+    
+    # Tests de parsing complets
+    results.append(("Message simple", test_swift_parsing(
+        "Message simple (YYMMDD)",
+        TEST_MESSAGE_1_SIMPLE,
+        "Format basique avec date YYMMDD"
+    )))
+    
+    results.append(("Message complet", test_swift_parsing(
+        "Message complet (YYYYMMDD)",
+        TEST_MESSAGE_2_FULL_DATE,
+        "Tous les champs avec banques intermédiaires"
+    )))
+    
+    results.append(("Multi-lignes", test_swift_parsing(
+        "Message multi-lignes",
+        TEST_MESSAGE_3_MULTILINE,
+        "Adresses complètes sur plusieurs lignes"
+    )))
+    
+    results.append(("Européen", test_swift_parsing(
+        "Message européen",
+        TEST_MESSAGE_4_EUROPEAN,
+        "IBAN suisse et allemand"
+    )))
+    
+    results.append(("Minimal", test_swift_parsing(
+        "Message minimal",
+        TEST_MESSAGE_5_MINIMAL,
+        "Uniquement les champs obligatoires"
+    )))
+    
+    results.append(("Format anglais", test_swift_parsing(
+        "Message avec virgule (format anglais)",
+        TEST_MESSAGE_6_WITH_COMMA_ENGLISH,
+        "Montant 1,234.56 (virgule = milliers, point = décimales)"
+    )))
+    
+    results.append(("Format européen", test_swift_parsing(
+        "Message avec virgule (format européen)",
+        TEST_MESSAGE_6_WITH_COMMA_EUROPEAN,
+        "Montant 1.234,56 (point = milliers, virgule = décimales)"
+    )))
+    
+    results.append(("International", test_swift_parsing(
+        "Message international",
+        TEST_MESSAGE_7_INTERNATIONAL,
+        "Transfert intercontinental avec JPY"
+    )))
+    
+    # Résumé
+    print("\n" + "=" * 60)
+    print("RÉSUMÉ DES TESTS")
+    print("=" * 60)
+    
+    passed = sum(1 for _, result in results if result)
+    total = len(results)
+    
+    for name, result in results:
+        status = "✅ PASSÉ" if result else "❌ ÉCHOUÉ"
+        print(f"{status}: {name}")
+    
+    print(f"\nTotal: {passed}/{total} tests réussis")
+    
+    if passed == total:
+        print("\n🎉 Tous les tests sont passés!")
+    else:
+        print(f"\n��️ {total - passed} test(s) ont échoué")
+
+
+if __name__ == "__main__":
+    run_all_tests()
+

pydanticai_app/agents.py

@@ -0,0 +1,41 @@
+"""PydanticAI agents for finance questions."""
+
+from pydantic import BaseModel, Field
+from pydantic_ai import Agent, ModelSettings
+
+from pydanticai_app.models import finance_model
+from pydanticai_app.config import settings
+
+
+class FinanceAnswer(BaseModel):
+    """Response model for finance questions."""
+    answer: str = Field(description="The answer to the finance question in French")
+    confidence: float = Field(description="Confidence level between 0 and 1", ge=0.0, le=1.0)
+    key_terms: list[str] = Field(description="List of key financial terms mentioned in the answer")
+
+
+# Model settings for reasoning models
+# Qwen3 uses <think> tags which consume 40-60% of tokens
+# Increase max_tokens to allow complete responses
+agent_model_settings = ModelSettings(
+    max_output_tokens=settings.max_tokens,
+)
+
+# Create agent for French finance questions
+# Note: output_type will be specified at runtime in the endpoint
+# Note: max_tokens is set via model_settings for reasoning models (<think> tags)
+finance_agent = Agent(
+    finance_model,
+    model_settings=agent_model_settings,
+    system_prompt=(
+        "Vous êtes un assistant financier expert spécialisé dans la terminologie "
+        "financière française. Répondez TOUJOURS en français, de manière claire, "
+        "précise et concise. Fournissez des explications complètes mais sans "
+        "développements excessifs.\n\n"
+        "Pour chaque réponse, identifiez les termes clés financiers mentionnés "
+        "et estimez votre niveau de confiance dans la réponse (entre 0 et 1).\n\n"
+        "Note: Vous avez suffisamment de tokens (max_tokens={}) pour fournir des réponses complètes "
+        "incluant votre raisonnement.".format(settings.max_tokens)
+    ),
+)
+

pydanticai_app/config.py

@@ -0,0 +1,44 @@
+"""Application configuration."""
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    """Application settings."""
+    
+    # Hugging Face Space OpenAI API endpoint
+    hf_space_url: str = "https://jeanbaptdzd-open-finance-llm-8b.hf.space"
+    
+    # OpenAI-compatible API settings
+    api_key: str = "not-needed"  # No authentication required
+    model_name: str = "DragonLLM/qwen3-8b-fin-v1.0"
+    
+    # API configuration
+    timeout: float = 120.0
+    max_retries: int = 3
+    
+    # Generation settings for reasoning models
+    # Qwen3 uses <think> tags which consume 40-60% of tokens
+    # Increase max_tokens to allow complete responses
+    max_tokens: int = 1500  # Increased for reasoning models (was default ~800-1000)
+    
+    # Context window limits for Qwen-3 8B
+    # Base context window: 32,768 tokens (32K)
+    # Extended with YaRN: up to 128,000 tokens (128K)
+    # Current max_tokens is for generation, context input can use up to ~30K tokens
+    
+    # Generation limits
+    # Maximum theoretical generation: 20,000 tokens
+    # Practical limit depends on: context_window - input_tokens - safety_margin
+    # With typical input (~500 tokens), can generate up to ~30K tokens
+    max_generation_limit: int = 20000  # Theoretical maximum (rarely needed)
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+
+settings = Settings()
+

pydanticai_app/main.py

@@ -0,0 +1,77 @@
+"""Main FastAPI application entry point."""
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+
+from pydanticai_app.agents import FinanceAnswer, finance_agent
+from pydanticai_app.config import settings
+from pydanticai_app.utils import extract_answer_from_reasoning, extract_key_terms
+
+app = FastAPI(
+    title="Open Finance PydanticAI API",
+    description="Open Finance API using PydanticAI for LLM inference",
+    version="0.1.0"
+)
+
+
+class QuestionRequest(BaseModel):
+    """Request model for finance questions."""
+    question: str
+
+
+class QuestionResponse(BaseModel):
+    """Response model for finance questions."""
+    answer: str
+    confidence: float
+    key_terms: list[str]
+
+
+@app.get("/")
+async def root():
+    """Root endpoint."""
+    return {
+        "status": "ok",
+        "service": "Open Finance PydanticAI API",
+        "version": "0.1.0",
+        "model_source": settings.hf_space_url,
+        "model": settings.model_name,
+    }
+
+
+@app.get("/health")
+async def health():
+    """Health check endpoint."""
+    return {"status": "healthy"}
+
+
+@app.post("/ask", response_model=QuestionResponse)
+async def ask_question(request: QuestionRequest):
+    """Ask a finance question to the AI agent.
+    
+    Handles reasoning model responses by extracting the final answer
+    from <think> tags.
+    """
+    try:
+        # Run agent with simple text output (reasoning models return text with tags)
+        result = await finance_agent.run(request.question)
+        
+        # Get the raw response text from AgentRunResult
+        raw_response = result.output if hasattr(result, 'output') else str(result)
+        
+        # Extract answer from reasoning tags (<think> tags)
+        clean_answer = extract_answer_from_reasoning(str(raw_response))
+        
+        # Extract key terms from the cleaned answer
+        key_terms = extract_key_terms(clean_answer)
+        
+        # Estimate confidence based on answer quality
+        confidence = 0.9 if clean_answer and len(clean_answer) > 50 else 0.7
+        
+        return QuestionResponse(
+            answer=clean_answer,
+            confidence=confidence,
+            key_terms=key_terms,
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error processing question: {str(e)}")
+

pydanticai_app/models.py

@@ -0,0 +1,18 @@
+"""PydanticAI model configuration."""
+
+from pydantic_ai.models.openai import OpenAIModel
+from pydantic_ai.providers.openai import OpenAIProvider
+
+from pydanticai_app.config import settings
+
+# Create PydanticAI model using OpenAI-compatible endpoint from Hugging Face Space
+# The model name will be sent in the request, but the actual model is determined by the HF Space
+# Note: max_tokens will be set at the Agent level, not here
+finance_model = OpenAIModel(
+    model_name="gpt-3.5-turbo",  # Model name for API compatibility (HF Space will use its own model)
+    provider=OpenAIProvider(
+        base_url=f"{settings.hf_space_url}/v1",
+        api_key=settings.api_key,
+    ),
+)
+

pydanticai_app/utils.py

@@ -0,0 +1,72 @@
+"""Utility functions for handling reasoning model responses."""
+
+import re
+
+
+def extract_answer_from_reasoning(response: str) -> str:
+    """Extract the final answer from a response containing reasoning tags.
+    
+    The Qwen3 model returns responses in the format:
+    <think>...reasoning...</think>
+    Final answer here...
+    
+    Or sometimes just the reasoning tags without closing tag.
+    This function extracts only the final answer part.
+    """
+    if not response:
+        return ""
+    
+    # Method 1: Split on </think> tag (most common format)
+    if "</think>" in response:
+        parts = response.split("</think>", 1)
+        if len(parts) > 1:
+            return parts[1].strip()
+    
+    # Method 2: Remove reasoning tags and their content
+    # Match <think>...</think> (case insensitive, multi-line)
+    cleaned = re.sub(
+        r'<think>.*?</think>',
+        '',
+        response,
+        flags=re.DOTALL | re.IGNORECASE
+    )
+    
+    # Clean up any remaining whitespace
+    cleaned = cleaned.strip()
+    
+    # If we removed everything, return original (fallback)
+    if not cleaned:
+        return response.strip()
+    
+    return cleaned
+
+
+def extract_key_terms(text: str) -> list[str]:
+    """Extract key financial terms from text.
+    
+    This is a simple heuristic - could be improved with NLP.
+    """
+    # Common French financial terms patterns
+    financial_patterns = [
+        r'\bcrédit\b', r'\bprêt\b', r'\bdette\b', r'\bintérêt\b',
+        r'\btaux\b', r'\bcapital\b', r'\bdividende\b', r'\baction\b',
+        r'\bobligation\b', r'\bfonds\b', r'\bépargne\b', r'\binvestissement\b',
+        r'\bhypothèque\b', r'\bamortissement\b', r'\bvalorisation\b',
+        r'\bdate de valeur\b', r'\bescompte\b', r'\bconsignation\b',
+        r'\bmain levée\b', r'\bséquestre\b', r'\bnantissement\b',
+    ]
+    
+    found_terms = []
+    text_lower = text.lower()
+    
+    for pattern in financial_patterns:
+        if re.search(pattern, text_lower):
+            # Extract the matched term
+            match = re.search(pattern, text, re.IGNORECASE)
+            if match:
+                term = match.group(0).strip()
+                if term not in found_terms:
+                    found_terms.append(term)
+    
+    return found_terms[:10]  # Limit to 10 terms
+

quick_test.py

@@ -1,54 +0,0 @@
-#!/usr/bin/env python3
-"""Quick test of Space API"""
-import httpx
-import sys
-
-SPACE_URL = "https://jeanbaptdzd-open-finance-llm-8b.hf.space"
-
-try:
-    # Test root endpoint
-    r = httpx.get(f"{SPACE_URL}/", timeout=10)
-    if r.status_code == 200:
-        data = r.json()
-        print(f"✓ Root endpoint: {data.get('backend', 'unknown')}")
-        print(f"  Model: {data.get('model', 'unknown')}")
-    else:
-        print(f"✗ Root endpoint failed: {r.status_code}")
-        sys.exit(1)
-    
-    # Test models endpoint
-    r = httpx.get(f"{SPACE_URL}/v1/models", timeout=10)
-    if r.status_code == 200:
-        data = r.json()
-        models = data.get('data', [])
-        print(f"✓ Models endpoint: {len(models)} model(s)")
-    else:
-        print(f"✗ Models endpoint failed: {r.status_code}")
-        sys.exit(1)
-    
-    # Test chat completion (short)
-    r = httpx.post(
-        f"{SPACE_URL}/v1/chat/completions",
-        json={
-            "model": "DragonLLM/qwen3-8b-fin-v1.0",
-            "messages": [{"role": "user", "content": "Say hello"}],
-            "max_tokens": 50
-        },
-        timeout=60
-    )
-    if r.status_code == 200:
-        data = r.json()
-        content = data['choices'][0]['message']['content']
-        print(f"✓ Chat completion: {len(content)} chars")
-        print(f"  Preview: {content[:50]}...")
-    else:
-        print(f"✗ Chat completion failed: {r.status_code}")
-        print(f"  Response: {r.text[:200]}")
-        sys.exit(1)
-    
-    print("\n✓ All tests passed! Space is working.")
-    
-except Exception as e:
-    print(f"✗ Error: {e}")
-    sys.exit(1)
-

test_eos_fix.py

@@ -1,148 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test that the EOS token fix is working properly
-Verify: no regressions, better completion, proper finish_reason
-"""
-import httpx
-import json
-import time
-
-BASE_URL = "https://jeanbaptdzd-open-finance-llm-8b.hf.space"
-
-def check_space_status():
-    """Check if Space is running"""
-    try:
-        response = httpx.get(f"{BASE_URL}/", timeout=10.0)
-        data = response.json()
-        return data.get("status") == "ok" and data.get("backend") == "Transformers"
-    except:
-        return False
-
-print("="*80)
-print("TESTING EOS TOKEN FIX")
-print("="*80)
-
-if not check_space_status():
-    print("❌ Space not ready. Please wait for rebuild.")
-    exit(1)
-
-print("✅ Space is ready\n")
-
-# Test 1: Check finish_reason is accurate
-print("[TEST 1] Verify finish_reason accuracy")
-print("-" * 80)
-
-response = httpx.post(
-    f"{BASE_URL}/v1/chat/completions",
-    json={
-        "model": "DragonLLM/qwen3-8b-fin-v1.0",
-        "messages": [{"role": "user", "content": "What is 2+2? Answer in 5 words."}],
-        "max_tokens": 50,
-        "temperature": 0.3
-    },
-    timeout=60.0
-)
-
-data = response.json()
-finish = data["choices"][0]["finish_reason"]
-content = data["choices"][0]["message"]["content"]
-tokens = data.get("usage", {}).get("completion_tokens", 0)
-
-print(f"Max tokens: 50")
-print(f"Generated: {tokens} tokens")
-print(f"Finish reason: {finish}")
-print(f"Response: {content[:150]}...")
-
-if finish == "stop" and tokens < 50:
-    print("✅ PASS: Stopped naturally with EOS token (not length limit)")
-elif finish == "length" and tokens >= 50:
-    print("✅ PASS: Correctly detected length limit")
-else:
-    print(f"⚠️  Unexpected: finish={finish}, tokens={tokens}")
-
-# Test 2: Check complete French answer
-print("\n[TEST 2] Complete French answer")
-print("-" * 80)
-
-response = httpx.post(
-    f"{BASE_URL}/v1/chat/completions",
-    json={
-        "model": "DragonLLM/qwen3-8b-fin-v1.0",
-        "messages": [{"role": "user", "content": "Qu'est-ce qu'une obligation? Soyez concis."}],
-        "max_tokens": 300,
-        "temperature": 0.3
-    },
-    timeout=60.0
-)
-
-data = response.json()
-content = data["choices"][0]["message"]["content"]
-finish = data["choices"][0]["finish_reason"]
-tokens = data.get("usage", {}).get("completion_tokens", 0)
-
-# Extract answer
-if "</think>" in content:
-    answer = content.split("</think>")[1].strip()
-else:
-    answer = content
-
-print(f"Generated: {tokens} tokens")
-print(f"Finish reason: {finish}")
-print(f"\nFull answer:\n{answer}\n")
-
-# Check completeness
-ends_properly = answer.rstrip().endswith((".", "!", "?", ")", "]"))
-has_french = any(c in answer for c in ["é", "è", "à", "ç"])
-
-print(f"Ends properly: {ends_properly}")
-print(f"Is French: {has_french}")
-print(f"Finish: {finish}")
-
-if ends_properly and finish == "stop" and has_french:
-    print("✅ PASS: Complete French answer with proper EOS")
-else:
-    print(f"⚠️  Check: ends={ends_properly}, finish={finish}, french={has_french}")
-
-# Test 3: Long answer completeness
-print("\n[TEST 3] Long answer completeness")
-print("-" * 80)
-
-response = httpx.post(
-    f"{BASE_URL}/v1/chat/completions",
-    json={
-        "model": "DragonLLM/qwen3-8b-fin-v1.0",
-        "messages": [{"role": "user", "content": "Expliquez en détail le nantissement de compte-titres."}],
-        "temperature": 0.3
-        # Use default max_tokens (1500)
-    },
-    timeout=90.0
-)
-
-data = response.json()
-content = data["choices"][0]["message"]["content"]
-finish = data["choices"][0]["finish_reason"]
-tokens = data.get("usage", {}).get("completion_tokens", 0)
-
-if "</think>" in content:
-    answer = content.split("</think>")[1].strip()
-else:
-    answer = content
-
-print(f"Generated: {tokens} tokens (default max: 1500)")
-print(f"Finish reason: {finish}")
-print(f"Answer length: {len(answer)} chars")
-print(f"Last 150 chars: ...{answer[-150:]}")
-
-if finish == "stop":
-    print("✅ PASS: Model stopped naturally at EOS (complete answer)")
-elif finish == "length":
-    print(f"⚠️  Hit token limit - may need higher max_tokens for complex questions")
-else:
-    print(f"❌ Unexpected finish_reason: {finish}")
-
-print("\n" + "="*80)
-print("SUMMARY")
-print("="*80)
-print("If all tests show 'stop' finish_reason and proper sentence endings,")
-print("the EOS token fix is working correctly!")
-

test_french_finance.py

@@ -1,128 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test French finance queries against the OpenAI-compatible API.
-"""
-
-import os
-import sys
-import asyncio
-import httpx
-from typing import Dict, Any
-
-# Default API URL (can be overridden with API_URL env var)
-API_URL = os.getenv("API_URL", "http://localhost:7860/v1")
-API_KEY = os.getenv("SERVICE_API_KEY")
-
-# French finance test questions
-FRENCH_QUESTS = [
-    {
-        "name": "Obligations",
-        "question": "Qu'est-ce qu'une obligation?",
-        "max_tokens": 400,
-    },
-    {
-        "name": "SICAV",
-        "question": "Qu'est-ce qu'une SICAV?",
-        "max_tokens": 400,
-    },
-    {
-        "name": "CAC 40",
-        "question": "Expliquez le CAC 40",
-        "max_tokens": 500,
-    },
-    {
-        "name": "VaR",
-        "question": "Qu'est-ce que la Value at Risk (VaR) et comment la calcule-t-on?",
-        "max_tokens": 600,
-    },
-]
-
-
-async def test_french_query(client: httpx.AsyncClient, test: Dict[str, Any]) -> Dict[str, Any]:
-    """Test a single French finance query."""
-    headers = {"Content-Type": "application/json"}
-    if API_KEY:
-        headers["x-api-key"] = API_KEY
-
-    payload = {
-        "model": "DragonLLM/qwen3-8b-fin-v1.0",
-        "messages": [{"role": "user", "content": test["question"]}],
-        "temperature": 0.7,
-        "max_tokens": test["max_tokens"],
-    }
-
-    try:
-        response = await client.post(
-            f"{API_URL}/chat/completions",
-            json=payload,
-            headers=headers,
-            timeout=120.0,
-        )
-        response.raise_for_status()
-        data = response.json()
-
-        return {
-            "name": test["name"],
-            "success": True,
-            "question": test["question"],
-            "answer": data["choices"][0]["message"]["content"],
-            "finish_reason": data["choices"][0]["finish_reason"],
-            "tokens": data["usage"]["completion_tokens"],
-            "total_tokens": data["usage"]["total_tokens"],
-        }
-    except Exception as e:
-        return {
-            "name": test["name"],
-            "success": False,
-            "question": test["question"],
-            "error": str(e),
-        }
-
-
-async def main():
-    """Run all French finance tests."""
-    print("=" * 70)
-    print("French Finance Test Suite")
-    print("=" * 70)
-    print(f"API URL: {API_URL}")
-    print()
-
-    async with httpx.AsyncClient() as client:
-        results = []
-        for i, test in enumerate(FRENCH_QUESTS, 1):
-            print(f"[{i}/{len(FRENCH_QUESTS)}] Testing: {test['name']}")
-            print(f"  Question: {test['question']}")
-            result = await test_french_query(client, test)
-            results.append(result)
-
-            if result["success"]:
-                answer_preview = result["answer"][:150] + "..." if len(result["answer"]) > 150 else result["answer"]
-                print(f"  ✓ Success")
-                print(f"  Finish reason: {result['finish_reason']}")
-                print(f"  Tokens: {result['tokens']}")
-                print(f"  Answer preview: {answer_preview}")
-            else:
-                print(f"  ✗ Failed: {result['error']}")
-            print()
-
-    # Summary
-    print("=" * 70)
-    print("Summary")
-    print("=" * 70)
-    passed = sum(1 for r in results if r["success"])
-    print(f"Passed: {passed}/{len(results)}")
-    
-    if passed == len(results):
-        print("✓ All tests passed!")
-        return 0
-    else:
-        print("✗ Some tests failed")
-        for r in results:
-            if not r["success"]:
-                print(f"  - {r['name']}: {r['error']}")
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(asyncio.run(main()))
-

test_new_features.py

@@ -1,214 +0,0 @@
-#!/usr/bin/env python3
-"""Test script for new features: health check, stats, rate limiting."""
-
-import sys
-import time
-import httpx
-from typing import Dict, Any
-
-
-API_URL = "http://localhost:8080"
-
-
-async def test_health_endpoint(client: httpx.AsyncClient) -> Dict[str, Any]:
-    """Test health endpoint with model readiness check."""
-    print("Testing /health endpoint...")
-    try:
-        response = await client.get(f"{API_URL}/health")
-        assert response.status_code == 200, f"Expected 200, got {response.status_code}"
-        data = response.json()
-        
-        # Check required fields
-        assert "status" in data, "Missing 'status' field"
-        assert "model_ready" in data, "Missing 'model_ready' field"
-        assert "service" in data, "Missing 'service' field"
-        
-        print(f"  ✓ Status: {data['status']}")
-        print(f"  ✓ Model ready: {data['model_ready']}")
-        print(f"  ✓ Service: {data['service']}")
-        
-        return {"success": True, "data": data}
-    except Exception as e:
-        print(f"  ✗ Failed: {e}")
-        return {"success": False, "error": str(e)}
-
-
-async def test_stats_endpoint(client: httpx.AsyncClient) -> Dict[str, Any]:
-    """Test stats endpoint."""
-    print("\nTesting /v1/stats endpoint...")
-    try:
-        response = await client.get(f"{API_URL}/v1/stats")
-        assert response.status_code == 200, f"Expected 200, got {response.status_code}"
-        data = response.json()
-        
-        # Check required fields
-        required_fields = [
-            "uptime_seconds", "total_requests", "total_tokens",
-            "average_total_tokens", "requests_per_hour", "tokens_per_hour"
-        ]
-        for field in required_fields:
-            assert field in data, f"Missing '{field}' field"
-        
-        print(f"  ✓ Uptime: {data['uptime_seconds']}s ({data.get('uptime_hours', 0):.2f}h)")
-        print(f"  ✓ Total requests: {data['total_requests']}")
-        print(f"  ✓ Total tokens: {data['total_tokens']}")
-        print(f"  ✓ Average tokens: {data['average_total_tokens']:.2f}")
-        print(f"  ✓ Requests/hour: {data['requests_per_hour']:.2f}")
-        print(f"  ✓ Tokens/hour: {data['tokens_per_hour']:.2f}")
-        
-        if data.get('requests_by_model'):
-            print(f"  ✓ Models used: {list(data['requests_by_model'].keys())}")
-        
-        if data.get('finish_reasons'):
-            print(f"  ✓ Finish reasons: {data['finish_reasons']}")
-        
-        return {"success": True, "data": data}
-    except Exception as e:
-        print(f"  ✗ Failed: {e}")
-        return {"success": False, "error": str(e)}
-
-
-async def test_rate_limiting(client: httpx.AsyncClient) -> Dict[str, Any]:
-    """Test rate limiting (should allow requests, check headers)."""
-    print("\nTesting rate limiting...")
-    try:
-        # Make a request to check rate limit headers
-        response = await client.get(f"{API_URL}/v1/models")
-        assert response.status_code == 200, f"Expected 200, got {response.status_code}"
-        
-        # Check for rate limit headers
-        headers = response.headers
-        rate_limit_headers = [
-            "X-RateLimit-Limit-Minute",
-            "X-RateLimit-Limit-Hour",
-            "X-RateLimit-Remaining-Minute",
-            "X-RateLimit-Remaining-Hour"
-        ]
-        
-        found_headers = []
-        for header in rate_limit_headers:
-            if header in headers:
-                found_headers.append(header)
-                print(f"  ✓ {header}: {headers[header]}")
-        
-        if len(found_headers) == len(rate_limit_headers):
-            print("  ✓ All rate limit headers present")
-            return {"success": True, "headers": {h: headers[h] for h in rate_limit_headers}}
-        else:
-            missing = set(rate_limit_headers) - set(found_headers)
-            print(f"  ⚠ Missing headers: {missing}")
-            return {"success": False, "error": f"Missing headers: {missing}"}
-            
-    except Exception as e:
-        print(f"  ✗ Failed: {e}")
-        return {"success": False, "error": str(e)}
-
-
-async def test_error_sanitization(client: httpx.AsyncClient) -> Dict[str, Any]:
-    """Test that error messages are sanitized."""
-    print("\nTesting error sanitization...")
-    try:
-        # Make an invalid request
-        response = await client.post(
-            f"{API_URL}/v1/chat/completions",
-            json={
-                "model": "test",
-                "messages": [],  # Empty messages should fail
-            }
-        )
-        
-        assert response.status_code == 400, f"Expected 400, got {response.status_code}"
-        data = response.json()
-        
-        # Check error structure
-        assert "error" in data, "Missing 'error' field"
-        assert "message" in data["error"], "Missing 'message' in error"
-        assert "type" in data["error"], "Missing 'type' in error"
-        
-        error_msg = data["error"]["message"]
-        # Should not contain internal details like file paths, stack traces, etc.
-        internal_indicators = ["Traceback", "File", "line", ".py", "Exception:"]
-        for indicator in internal_indicators:
-            assert indicator.lower() not in error_msg.lower(), f"Error message contains internal details: {indicator}"
-        
-        print(f"  ✓ Error properly formatted: {error_msg[:100]}")
-        print(f"  ✓ Error type: {data['error']['type']}")
-        
-        return {"success": True, "error": data["error"]}
-    except Exception as e:
-        print(f"  ✗ Failed: {e}")
-        return {"success": False, "error": str(e)}
-
-
-async def test_root_endpoint(client: httpx.AsyncClient) -> Dict[str, Any]:
-    """Test root endpoint."""
-    print("\nTesting / endpoint...")
-    try:
-        response = await client.get(f"{API_URL}/")
-        assert response.status_code == 200, f"Expected 200, got {response.status_code}"
-        data = response.json()
-        
-        assert "status" in data, "Missing 'status' field"
-        print(f"  ✓ Status: {data['status']}")
-        print(f"  ✓ Service: {data.get('service', 'N/A')}")
-        
-        return {"success": True, "data": data}
-    except Exception as e:
-        print(f"  ✗ Failed: {e}")
-        return {"success": False, "error": str(e)}
-
-
-async def main():
-    """Run all tests."""
-    print("=" * 70)
-    print("Testing New Features")
-    print("=" * 70)
-    print(f"API URL: {API_URL}")
-    print()
-    
-    timeout = httpx.Timeout(30.0, connect=10.0)
-    async with httpx.AsyncClient(timeout=timeout) as client:
-        results = []
-        
-        # Test root endpoint
-        results.append(await test_root_endpoint(client))
-        
-        # Test health endpoint
-        results.append(await test_health_endpoint(client))
-        
-        # Test stats endpoint (before any requests)
-        results.append(await test_stats_endpoint(client))
-        
-        # Test rate limiting
-        results.append(await test_rate_limiting(client))
-        
-        # Test error sanitization
-        results.append(await test_error_sanitization(client))
-        
-        # Test stats endpoint again (after requests)
-        print("\nTesting /v1/stats endpoint (after requests)...")
-        results.append(await test_stats_endpoint(client))
-    
-    # Summary
-    print("\n" + "=" * 70)
-    print("Summary")
-    print("=" * 70)
-    passed = sum(1 for r in results if r["success"])
-    total = len(results)
-    print(f"Passed: {passed}/{total}")
-    
-    if passed == total:
-        print("✓ All tests passed!")
-        return 0
-    else:
-        print("✗ Some tests failed")
-        for i, r in enumerate(results, 1):
-            if not r["success"]:
-                print(f"  Test {i}: {r.get('error', 'Unknown error')}")
-        return 1
-
-
-if __name__ == "__main__":
-    import asyncio
-    sys.exit(asyncio.run(main()))
-

test_pydanticai.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""Test script for PydanticAI integration."""
+
+import asyncio
+import sys
+from pydanticai_app.agents import finance_agent
+from pydanticai_app.utils import extract_answer_from_reasoning, extract_key_terms
+
+
+async def test_finance_agent():
+    """Test the finance agent."""
+    print("=" * 70)
+    print("Testing PydanticAI Finance Agent")
+    print("=" * 70)
+    print()
+    
+    test_questions = [
+        "Qu'est-ce qu'une obligation?",
+        "Expliquez le concept de date de valeur.",
+        "Qu'est-ce que le CAC 40?",
+    ]
+    
+    for i, question in enumerate(test_questions, 1):
+        print(f"[{i}/{len(test_questions)}] Question: {question}")
+        print("-" * 70)
+        
+        try:
+            # Run agent
+            result = await finance_agent.run(question)
+            
+            # Get raw response
+            raw_response = result.output if hasattr(result, 'output') else str(result)
+            
+            # Extract answer from reasoning tags
+            clean_answer = extract_answer_from_reasoning(str(raw_response))
+            
+            # Extract key terms
+            key_terms = extract_key_terms(clean_answer)
+            
+            print(f"✅ Response received")
+            print(f"Answer length: {len(clean_answer)} chars")
+            print(f"Key terms: {key_terms[:5]}")
+            print(f"Answer preview: {clean_answer[:200]}...")
+            print()
+            
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            import traceback
+            traceback.print_exc()
+            print()
+            return False
+    
+    print("=" * 70)
+    print("✅ All tests passed!")
+    print("=" * 70)
+    return True
+
+
+if __name__ == "__main__":
+    success = asyncio.run(test_finance_agent())
+    sys.exit(0 if success else 1)
+

test_regression.py

@@ -1,118 +0,0 @@
-#!/usr/bin/env python3
-"""
-Regression test: verify EOS token fix improves completeness without breaking anything
-"""
-import httpx
-import json
-import time
-
-BASE_URL = "https://jeanbaptdzd-open-finance-llm-8b.hf.space"
-
-print("="*80)
-print("REGRESSION & IMPROVEMENT TEST")
-print("="*80)
-
-# Test 1: Basic functionality still works
-print("\n[1] Basic functionality check")
-try:
-    response = httpx.post(
-        f"{BASE_URL}/v1/chat/completions",
-        json={
-            "model": "DragonLLM/qwen3-8b-fin-v1.0",
-            "messages": [{"role": "user", "content": "What is 2+2?"}],
-            "max_tokens": 100,
-            "temperature": 0.3
-        },
-        timeout=30.0
-    )
-    
-    data = response.json()
-    if "error" not in data:
-        print(f"✅ Basic request works")
-    else:
-        print(f"❌ Error: {data['error']['message']}")
-except Exception as e:
-    print(f"❌ Exception: {e}")
-
-time.sleep(3)
-
-# Test 2: French answer with reasonable token limit
-print("\n[2] French answer (500 tokens)")
-try:
-    response = httpx.post(
-        f"{BASE_URL}/v1/chat/completions",
-        json={
-            "model": "DragonLLM/qwen3-8b-fin-v1.0",
-            "messages": [{"role": "user", "content": "Qu'est-ce qu'une obligation? Réponse courte."}],
-            "max_tokens": 500,
-            "temperature": 0.3
-        },
-        timeout=45.0
-    )
-    
-    data = response.json()
-    if "error" in data:
-        print(f"❌ Error: {data['error']['message'][:100]}")
-    else:
-        content = data["choices"][0]["message"]["content"]
-        finish = data["choices"][0]["finish_reason"]
-        tokens = data.get("usage", {}).get("completion_tokens", 0)
-        
-        answer = content.split("</think>")[1].strip() if "</think>" in content else content
-        
-        print(f"Tokens: {tokens}/500")
-        print(f"Finish: {finish}")
-        print(f"Answer: {answer}")
-        print(f"Ends properly: {answer.rstrip().endswith(('.', '!', '?'))}")
-        
-        if finish == "stop":
-            print(f"✅ IMPROVEMENT: Stopped naturally at EOS (was hitting length before)")
-        elif finish == "length":
-            print(f"⚠️  Still hitting length limit")
-            
-except Exception as e:
-    print(f"❌ Exception: {e}")
-
-time.sleep(3)
-
-# Test 3: Sequential requests (no OOM regression)
-print("\n[3] Sequential requests (memory check)")
-success = 0
-for i in range(1, 4):
-    try:
-        response = httpx.post(
-            f"{BASE_URL}/v1/chat/completions",
-            json={
-                "model": "DragonLLM/qwen3-8b-fin-v1.0",
-                "messages": [{"role": "user", "content": f"Calculate {i}+{i}"}],
-                "max_tokens": 200,
-                "temperature": 0.3
-            },
-            timeout=30.0
-        )
-        
-        data = response.json()
-        if "error" not in data:
-            success += 1
-            print(f"  [{i}] ✅")
-        else:
-            if "out of memory" in data["error"]["message"].lower():
-                print(f"  [{i}] ❌ OOM!")
-            else:
-                print(f"  [{i}] ❌ Error")
-        time.sleep(2)
-    except:
-        print(f"  [{i}] ❌ Timeout/Exception")
-
-if success == 3:
-    print(f"✅ NO REGRESSION: Memory management still working")
-else:
-    print(f"❌ REGRESSION: Only {success}/3 succeeded")
-
-print("\n" + "="*80)
-print("VERDICT")
-print("="*80)
-print("If Test 2 shows finish='stop' → EOS fix is working ✅")
-print("If Test 2 shows finish='length' → Need more investigation ⚠️")
-print("If Test 3 passes → No memory regression ✅")
-

test_space_api.py

@@ -1,142 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test the Hugging Face Space API to verify the refactored code works.
-"""
-
-import os
-import sys
-import asyncio
-import httpx
-from typing import Dict, Any
-
-# Space URL - update this if your Space has a different URL
-SPACE_URL = os.getenv("SPACE_URL", "https://jeanbaptdzd-open-finance-llm-8b.hf.space/v1")
-API_KEY = os.getenv("SERVICE_API_KEY")
-
-
-async def test_endpoint(client: httpx.AsyncClient, name: str, method: str, url: str, **kwargs) -> Dict[str, Any]:
-    """Test a single API endpoint."""
-    try:
-        headers = kwargs.pop("headers", {})
-        if API_KEY:
-            headers["x-api-key"] = API_KEY
-        
-        if method.upper() == "GET":
-            response = await client.get(url, headers=headers, timeout=30.0)
-        elif method.upper() == "POST":
-            response = await client.post(url, headers=headers, timeout=120.0, **kwargs)
-        else:
-            return {"name": name, "success": False, "error": f"Unsupported method: {method}"}
-        
-        response.raise_for_status()
-        return {
-            "name": name,
-            "success": True,
-            "status_code": response.status_code,
-            "data": response.json() if response.headers.get("content-type", "").startswith("application/json") else response.text[:200],
-        }
-    except Exception as e:
-        return {
-            "name": name,
-            "success": False,
-            "error": str(e),
-        }
-
-
-async def main():
-    """Run API tests."""
-    print("=" * 70)
-    print("Testing Hugging Face Space API")
-    print("=" * 70)
-    print(f"Space URL: {SPACE_URL}")
-    print()
-    
-    async with httpx.AsyncClient() as client:
-        results = []
-        
-        # Test 1: Root endpoint
-        print("[1/4] Testing root endpoint...")
-        result = await test_endpoint(client, "Root", "GET", SPACE_URL.replace("/v1", ""))
-        results.append(result)
-        if result["success"]:
-            print(f"  ✓ Success: {result.get('data', {}).get('status', 'ok')}")
-        else:
-            print(f"  ✗ Failed: {result['error']}")
-        print()
-        
-        # Test 2: List models
-        print("[2/4] Testing /v1/models endpoint...")
-        result = await test_endpoint(client, "List Models", "GET", f"{SPACE_URL}/models")
-        results.append(result)
-        if result["success"]:
-            models = result.get("data", {}).get("data", [])
-            print(f"  ✓ Success: Found {len(models)} model(s)")
-            if models:
-                print(f"    Model: {models[0].get('id', 'unknown')}")
-        else:
-            print(f"  ✗ Failed: {result['error']}")
-        print()
-        
-        # Test 3: Chat completion (simple)
-        print("[3/4] Testing /v1/chat/completions endpoint...")
-        result = await test_endpoint(
-            client,
-            "Chat Completion",
-            "POST",
-            f"{SPACE_URL}/chat/completions",
-            json={
-                "model": "DragonLLM/qwen3-8b-fin-v1.0",
-                "messages": [{"role": "user", "content": "What is compound interest? Answer in one sentence."}],
-                "temperature": 0.7,
-                "max_tokens": 100,
-            }
-        )
-        results.append(result)
-        if result["success"]:
-            data = result.get("data", {})
-            content = data.get("choices", [{}])[0].get("message", {}).get("content", "")
-            tokens = data.get("usage", {}).get("total_tokens", 0)
-            print(f"  ✓ Success: Generated {tokens} tokens")
-            print(f"    Response preview: {content[:100]}...")
-        else:
-            print(f"  ✗ Failed: {result['error']}")
-        print()
-        
-        # Test 4: Model reload endpoint
-        print("[4/4] Testing /v1/models/reload endpoint...")
-        result = await test_endpoint(
-            client,
-            "Model Reload",
-            "POST",
-            f"{SPACE_URL}/models/reload",
-            params={"force": False}
-        )
-        results.append(result)
-        if result["success"]:
-            data = result.get("data", {})
-            print(f"  ✓ Success: {data.get('message', 'OK')}")
-        else:
-            print(f"  ✗ Failed: {result['error']}")
-        print()
-        
-    # Summary
-    print("=" * 70)
-    print("Test Summary")
-    print("=" * 70)
-    passed = sum(1 for r in results if r["success"])
-    print(f"Passed: {passed}/{len(results)}")
-    
-    if passed == len(results):
-        print("✓ All tests passed! The Space is working correctly.")
-        return 0
-    else:
-        print("✗ Some tests failed")
-        for r in results:
-            if not r["success"]:
-                print(f"  - {r['name']}: {r['error']}")
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(asyncio.run(main()))
-

tests/performance/__init__.py

@@ -6,3 +6,11 @@
 
 
 
+
+
+
+
+
+
+
+