Remove PydanticAI integration and examples

- Remove pydanticai_app/ directory (PydanticAI integration moved to open-finance-pydanticAI repo)
- Remove test_pydanticai.py test script
- Remove examples/ directory with all PydanticAI example scripts
- Update README.md to remove PydanticAI references and focus on OpenAI-compatible API
- Repository now focuses solely on OpenAI-compatible API wrapper

README.md

@@ -25,7 +25,8 @@ This service provides an OpenAI-compatible API for the DragonLLM Qwen3-8B financ
 - ✅ **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
+- ✅ **Tool Calls Support** - OpenAI-compatible tool/function calling
+- ✅ **Structured Outputs** - JSON format support via response_format
 
 ## API Endpoints
 
@@ -96,21 +97,6 @@ Token priority: `HF_TOKEN_LC2` > `HF_TOKEN_LC` > `HF_TOKEN` > `HUGGING_FACE_HUB_
 
 ## 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
@@ -177,9 +163,6 @@ pytest -v
 
 # Test deployment
 ./test_deployment.sh
-
-# Test PydanticAI integration
-python test_pydanticai.py
 ```
 
 ## Project Structure
@@ -192,8 +175,6 @@ python test_pydanticai.py
 │   ├── 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

examples/README.md

@@ -1,121 +0,0 @@
-# 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

@@ -1,157 +0,0 @@
-# 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

@@ -1,78 +0,0 @@
-"""
-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

@@ -1,139 +0,0 @@
-"""
-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

@@ -1,152 +0,0 @@
-"""
-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

@@ -1,540 +0,0 @@
-"""
-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

@@ -1,368 +0,0 @@
-"""
-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

@@ -1,365 +0,0 @@
-"""
-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

@@ -1,336 +0,0 @@
-"""
-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

@@ -1,106 +0,0 @@
-"""
-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

@@ -1,355 +0,0 @@
-"""
-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

@@ -1,41 +0,0 @@
-"""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

@@ -1,44 +0,0 @@
-"""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/Qwen-Open-Finance-R-8B"
-    
-    # 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

@@ -1,77 +0,0 @@
-"""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

@@ -1,18 +0,0 @@
-"""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

@@ -1,72 +0,0 @@
-"""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
-

test_pydanticai.py

@@ -1,62 +0,0 @@
-#!/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_space_basic.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+"""Basic tests for the Hugging Face Space API."""
+
+import requests
+import json
+import time
+from typing import Dict, Any
+
+SPACE_URL = "https://jeanbaptdzd-open-finance-llm-8b.hf.space"
+API_BASE = f"{SPACE_URL}/v1"
+
+def test_health():
+    """Test if the Space is accessible."""
+    print("=" * 60)
+    print("Test 1: Health Check")
+    print("=" * 60)
+    try:
+        response = requests.get(f"{SPACE_URL}/health", timeout=10)
+        print(f"Status Code: {response.status_code}")
+        if response.status_code == 200:
+            print(f"Response: {response.json()}")
+            print("✅ Health check passed")
+            return True
+        else:
+            print(f"❌ Health check failed: {response.status_code}")
+            return False
+    except Exception as e:
+        print(f"❌ Health check error: {e}")
+        return False
+
+def test_list_models():
+    """Test listing available models."""
+    print("\n" + "=" * 60)
+    print("Test 2: List Models")
+    print("=" * 60)
+    try:
+        response = requests.get(f"{API_BASE}/models", timeout=10)
+        print(f"Status Code: {response.status_code}")
+        if response.status_code == 200:
+            data = response.json()
+            print(f"Response: {json.dumps(data, indent=2)}")
+            print("✅ List models passed")
+            return True
+        else:
+            print(f"❌ List models failed: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+    except Exception as e:
+        print(f"❌ List models error: {e}")
+        return False
+
+def test_simple_chat():
+    """Test basic chat completion."""
+    print("\n" + "=" * 60)
+    print("Test 3: Simple Chat Completion")
+    print("=" * 60)
+    try:
+        payload = {
+            "model": "dragon-llm-open-finance",
+            "messages": [
+                {"role": "user", "content": "Bonjour, dis-moi simplement 'test réussi'"}
+            ],
+            "temperature": 0.7,
+            "max_tokens": 50
+        }
+        print(f"Request: {json.dumps(payload, indent=2, ensure_ascii=False)}")
+        response = requests.post(
+            f"{API_BASE}/chat/completions",
+            json=payload,
+            timeout=120  # Increased timeout for model loading/generation
+        )
+        print(f"Status Code: {response.status_code}")
+        if response.status_code == 200:
+            data = response.json()
+            print(f"Response: {json.dumps(data, indent=2, ensure_ascii=False)}")
+            if "choices" in data and len(data["choices"]) > 0:
+                content = data["choices"][0]["message"].get("content", "")
+                print(f"\n✅ Chat completion passed")
+                print(f"Generated text: {content[:100]}...")
+                return True
+            else:
+                print("❌ No choices in response")
+                return False
+        else:
+            print(f"❌ Chat completion failed: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+    except Exception as e:
+        print(f"❌ Chat completion error: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def test_tool_choice_required():
+    """Test tool_choice='required' (our fix)."""
+    print("\n" + "=" * 60)
+    print("Test 4: tool_choice='required' (Fix Verification)")
+    print("=" * 60)
+    try:
+        payload = {
+            "model": "dragon-llm-open-finance",
+            "messages": [
+                {"role": "user", "content": "Dis bonjour"}
+            ],
+            "tools": [
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "say_hello",
+                        "description": "Say hello",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "name": {
+                                    "type": "string",
+                                    "description": "Name to greet"
+                                }
+                            }
+                        }
+                    }
+                }
+            ],
+            "tool_choice": "required",  # This should not cause 422 error anymore
+            "temperature": 0.7,
+            "max_tokens": 100
+        }
+        print(f"Request: tool_choice='required'")
+        response = requests.post(
+            f"{API_BASE}/chat/completions",
+            json=payload,
+            timeout=120  # Increased timeout for model loading/generation
+        )
+        print(f"Status Code: {response.status_code}")
+        if response.status_code == 200:
+            data = response.json()
+            print(f"✅ tool_choice='required' accepted (no 422 error)")
+            print(f"Response keys: {list(data.keys())}")
+            return True
+        elif response.status_code == 422:
+            print(f"❌ Still getting 422 error with tool_choice='required'")
+            print(f"Response: {response.text}")
+            return False
+        else:
+            print(f"⚠️  Unexpected status code: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+    except Exception as e:
+        print(f"❌ tool_choice test error: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def test_response_format():
+    """Test response_format for structured outputs (our fix)."""
+    print("\n" + "=" * 60)
+    print("Test 5: response_format (Fix Verification)")
+    print("=" * 60)
+    try:
+        payload = {
+            "model": "dragon-llm-open-finance",
+            "messages": [
+                {"role": "user", "content": "Donne-moi un nombre aléatoire entre 1 et 10 au format JSON: {\"nombre\": X}"}
+            ],
+            "response_format": {"type": "json_object"},
+            "temperature": 0.7,
+            "max_tokens": 50
+        }
+        print(f"Request: response_format={{'type': 'json_object'}}")
+        response = requests.post(
+            f"{API_BASE}/chat/completions",
+            json=payload,
+            timeout=120  # Increased timeout for model loading/generation
+        )
+        print(f"Status Code: {response.status_code}")
+        if response.status_code == 200:
+            data = response.json()
+            print(f"✅ response_format accepted")
+            if "choices" in data and len(data["choices"]) > 0:
+                content = data["choices"][0]["message"].get("content", "")
+                print(f"Generated content: {content}")
+                # Try to parse as JSON
+                try:
+                    json.loads(content)
+                    print("✅ Response is valid JSON")
+                    return True
+                except json.JSONDecodeError:
+                    print("⚠️  Response format requested but content is not JSON")
+                    return False
+            return True
+        else:
+            print(f"❌ response_format test failed: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+    except Exception as e:
+        print(f"❌ response_format test error: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def main():
+    """Run all tests."""
+    print("\n" + "=" * 60)
+    print("BASIC SPACE API TESTS")
+    print("=" * 60)
+    print(f"Testing Space: {SPACE_URL}")
+    print(f"API Base: {API_BASE}")
+    print()
+    
+    results = []
+    
+    # Wait a bit for Space to be ready
+    print("Waiting 5 seconds for Space to be ready...")
+    time.sleep(5)
+    
+    results.append(("Health Check", test_health()))
+    results.append(("List Models", test_list_models()))
+    results.append(("Simple Chat", test_simple_chat()))
+    results.append(("tool_choice='required'", test_tool_choice_required()))
+    results.append(("response_format", test_response_format()))
+    
+    # Summary
+    print("\n" + "=" * 60)
+    print("TEST SUMMARY")
+    print("=" * 60)
+    passed = sum(1 for _, result in results if result)
+    total = len(results)
+    for test_name, result in results:
+        status = "✅ PASS" if result else "❌ FAIL"
+        print(f"{status}: {test_name}")
+    print(f"\nTotal: {passed}/{total} tests passed")
+    
+    if passed == total:
+        print("\n🎉 All tests passed!")
+    else:
+        print(f"\n⚠️  {total - passed} test(s) failed")
+    
+    return passed == total
+
+if __name__ == "__main__":
+    success = main()
+    exit(0 if success else 1)
+

test_space_with_tools.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""Test Space API with tool calls and JSON format."""
+
+import requests
+import json
+import time
+from typing import Dict, Any
+
+SPACE_URL = "https://jeanbaptdzd-open-finance-llm-8b.hf.space"
+API_BASE = f"{SPACE_URL}/v1"
+
+def test_tool_calls():
+    """Test tool calls functionality."""
+    print("=" * 60)
+    print("Test: Tool Calls")
+    print("=" * 60)
+    try:
+        payload = {
+            "model": "dragon-llm-open-finance",
+            "messages": [
+                {
+                    "role": "user",
+                    "content": "Calcule la valeur future de 10000€ à 5% sur 10 ans en utilisant l'outil calculer_valeur_future"
+                }
+            ],
+            "tools": [
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "calculer_valeur_future",
+                        "description": "Calcule la valeur future d'un capital avec intérêts composés",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "capital_initial": {
+                                    "type": "number",
+                                    "description": "Capital initial en euros"
+                                },
+                                "taux": {
+                                    "type": "number",
+                                    "description": "Taux d'intérêt annuel (ex: 0.05 pour 5%)"
+                                },
+                                "duree": {
+                                    "type": "number",
+                                    "description": "Durée en années"
+                                }
+                            },
+                            "required": ["capital_initial", "taux", "duree"]
+                        }
+                    }
+                }
+            ],
+            "tool_choice": "auto",
+            "temperature": 0.7,
+            "max_tokens": 200
+        }
+        print(f"Request: tool_choice='auto', tools provided")
+        response = requests.post(
+            f"{API_BASE}/chat/completions",
+            json=payload,
+            timeout=120
+        )
+        print(f"Status Code: {response.status_code}")
+        if response.status_code == 200:
+            data = response.json()
+            print(f"✅ Tool calls request accepted")
+            if "choices" in data and len(data["choices"]) > 0:
+                message = data["choices"][0]["message"]
+                if "tool_calls" in message and message["tool_calls"]:
+                    print(f"✅ Tool calls found: {len(message['tool_calls'])}")
+                    for i, tool_call in enumerate(message["tool_calls"]):
+                        print(f"  Tool call {i+1}:")
+                        print(f"    ID: {tool_call.get('id', 'N/A')}")
+                        print(f"    Function: {tool_call.get('function', {}).get('name', 'N/A')}")
+                        print(f"    Arguments: {tool_call.get('function', {}).get('arguments', 'N/A')[:100]}...")
+                    return True
+                else:
+                    print(f"⚠️  No tool_calls in response")
+                    print(f"   Content: {message.get('content', '')[:200]}...")
+                    return False
+            return True
+        else:
+            print(f"❌ Tool calls test failed: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+    except Exception as e:
+        print(f"❌ Tool calls test error: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def test_tool_choice_required():
+    """Test tool_choice='required' with tools."""
+    print("\n" + "=" * 60)
+    print("Test: tool_choice='required' with Tools")
+    print("=" * 60)
+    try:
+        payload = {
+            "model": "dragon-llm-open-finance",
+            "messages": [
+                {
+                    "role": "user",
+                    "content": "Utilise l'outil pour calculer 10000€ à 5% sur 10 ans"
+                }
+            ],
+            "tools": [
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "calculer_valeur_future",
+                        "description": "Calcule la valeur future",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "capital_initial": {"type": "number"},
+                                "taux": {"type": "number"},
+                                "duree": {"type": "number"}
+                            },
+                            "required": ["capital_initial", "taux", "duree"]
+                        }
+                    }
+                }
+            ],
+            "tool_choice": "required",  # This should not cause 422 error
+            "temperature": 0.7,
+            "max_tokens": 200
+        }
+        print(f"Request: tool_choice='required'")
+        response = requests.post(
+            f"{API_BASE}/chat/completions",
+            json=payload,
+            timeout=120
+        )
+        print(f"Status Code: {response.status_code}")
+        if response.status_code == 200:
+            print(f"✅ tool_choice='required' accepted (no 422 error)")
+            return True
+        elif response.status_code == 422:
+            print(f"❌ Still getting 422 error with tool_choice='required'")
+            print(f"Response: {response.text}")
+            return False
+        else:
+            print(f"⚠️  Unexpected status: {response.status_code}")
+            return False
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return False
+
+def test_response_format_json():
+    """Test response_format with JSON output."""
+    print("\n" + "=" * 60)
+    print("Test: response_format JSON")
+    print("=" * 60)
+    try:
+        payload = {
+            "model": "dragon-llm-open-finance",
+            "messages": [
+                {
+                    "role": "user",
+                    "content": "Donne-moi un nombre aléatoire entre 1 et 10 au format JSON avec la clé 'nombre'"
+                }
+            ],
+            "response_format": {"type": "json_object"},
+            "temperature": 0.7,
+            "max_tokens": 100
+        }
+        print(f"Request: response_format={{'type': 'json_object'}}")
+        response = requests.post(
+            f"{API_BASE}/chat/completions",
+            json=payload,
+            timeout=120
+        )
+        print(f"Status Code: {response.status_code}")
+        if response.status_code == 200:
+            data = response.json()
+            print(f"✅ response_format accepted")
+            if "choices" in data and len(data["choices"]) > 0:
+                content = data["choices"][0]["message"].get("content", "")
+                print(f"Generated content (first 200 chars): {content[:200]}")
+                
+                # Try to parse as JSON
+                try:
+                    # Remove reasoning tags if present
+                    cleaned = content
+                    if "<think>" in cleaned.lower():
+                        # Try to extract JSON after reasoning
+                        if "}" in cleaned:
+                            brace_pos = cleaned.find('{')
+                            if brace_pos != -1:
+                                cleaned = cleaned[brace_pos:]
+                    
+                    json_data = json.loads(cleaned)
+                    print(f"✅ Response is valid JSON: {json_data}")
+                    return True
+                except json.JSONDecodeError as e:
+                    print(f"⚠️  Response is not valid JSON: {e}")
+                    print(f"   Full content: {content[:500]}")
+                    return False
+            return True
+        else:
+            print(f"❌ response_format test failed: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def main():
+    """Run all tests."""
+    print("\n" + "=" * 60)
+    print("SPACE API TESTS - TOOLS AND JSON FORMAT")
+    print("=" * 60)
+    print(f"Testing Space: {SPACE_URL}")
+    print()
+    
+    results = []
+    
+    results.append(("Tool Calls (auto)", test_tool_calls()))
+    results.append(("tool_choice='required'", test_tool_choice_required()))
+    results.append(("response_format JSON", test_response_format_json()))
+    
+    # Summary
+    print("\n" + "=" * 60)
+    print("TEST SUMMARY")
+    print("=" * 60)
+    passed = sum(1 for _, result in results if result)
+    total = len(results)
+    for test_name, result in results:
+        status = "✅ PASS" if result else "❌ FAIL"
+        print(f"{status}: {test_name}")
+    print(f"\nTotal: {passed}/{total} tests passed")
+    
+    return passed == total
+
+if __name__ == "__main__":
+    success = main()
+    exit(0 if success else 1)
+