jojdgldso

.env

@@ -0,0 +1,3 @@
+# Configuration pour Chatm2
+# Obtenez votre clé API Google Gemini sur https://aistudio.google.com/app/apikey
+GOOGLE_API_KEY=votre_cle_api_ici

AGENTS.md

@@ -0,0 +1,38 @@
+# AGENTS.md - Chatm2 Project Guidelines
+
+## Build/Lint/Test Commands
+- **Run app**: `python app.py` or `flask run --host=0.0.0.0 --port=7860`
+- **Install dependencies**: `pip install -r requirements.txt`
+- **Docker build**: `docker build -t chatm2 .`
+- **Docker run**: `docker run -p 7860:7860 chatm2`
+
+## Code Style Guidelines
+
+### Python Standards
+- **Imports**: Standard library first, then third-party, then local imports. One import per line.
+- **Naming**: snake_case for functions/variables, PascalCase for classes, UPPER_CASE for constants
+- **Types**: Use type hints for function parameters and return values when possible
+- **Error Handling**: Use try/except blocks with specific exceptions, log errors appropriately
+- **Docstrings**: Use triple quotes for function/class documentation in French (matching existing code)
+
+### Flask/Web Standards
+- **Routes**: Use descriptive route names, handle both GET/POST appropriately
+- **JSON Responses**: Use `jsonify()` for API responses, include error handling
+- **File Uploads**: Validate file types and sizes, use secure_filename()
+- **Templates**: Use Jinja2 templating with Tailwind CSS classes
+
+### Frontend/JavaScript
+- **Styling**: Use Tailwind CSS utility classes, maintain dark theme consistency
+- **Markdown**: Use marked.js for rendering, apply consistent styling
+- **Async**: Use modern async/await patterns for API calls
+
+### Security
+- **Environment Variables**: Store sensitive data in .env files, never commit secrets
+- **File Handling**: Validate uploads, limit file sizes (currently 16MB max)
+- **API Keys**: Load from environment variables only
+
+### Project Structure
+- Keep documentation in `documentation_gemini/` directory
+- Store templates in `templates/` directory
+- Use `SESSION_FILE_DIR/` for temporary file storage
+- Place system instructions in `instructions/` directory

README.md

@@ -1,3 +1,63 @@
+# Chatm2 - AI Assistant
+
+Assistant IA intelligent utilisant Google Gemini API avec interface web moderne.
+
+## Installation
+
+1. **Cloner le repository**
+   ```bash
+   git clone <repository-url>
+   cd chatm2
+   ```
+
+2. **Installer les dépendances**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. **Configuration de l'API**
+   - Obtenez une clé API Google Gemini sur [Google AI Studio](https://aistudio.google.com/app/apikey)
+   - Créez un fichier `.env` dans le répertoire racine :
+   ```
+   GOOGLE_API_KEY=votre_cle_api_ici
+   ```
+
+## Utilisation
+
+### Démarrage local
+```bash
+python app.py
+```
+L'application sera accessible sur http://localhost:5000
+
+### Avec Docker
+```bash
+docker build -t chatm2 .
+docker run -p 7860:7860 -e GOOGLE_API_KEY=votre_cle_api chatm2
+```
+
+## Fonctionnalités
+
+- Chat en temps réel avec streaming
+- Support des fichiers (images, documents)
+- Mode réflexion (thinking) activable
+- Historique des conversations
+- Interface d'administration
+
+## Debug
+
+- Endpoint de test API : `/debug/api_test`
+- Page admin : `/admin1`
+- Statistiques : `/admin/stats`
+
+## Dépannage
+
+Si vous ne recevez pas de réponses :
+1. Vérifiez que `GOOGLE_API_KEY` est définie
+2. Testez l'endpoint `/debug/api_test`
+3. Vérifiez les logs de l'application
+4. Assurez-vous que le modèle `gemini-2.5-flash` est accessible
+
 ---
 title: Chatm
 emoji: 📚

app.py

@@ -29,7 +29,17 @@ def load_system_instruction():
 API_KEY = os.getenv("GOOGLE_API_KEY")
 SYSTEM_INSTRUCTION = load_system_instruction()
 
-client = genai.Client(api_key=API_KEY)
+if not API_KEY:
+    print("ATTENTION: GOOGLE_API_KEY non définie dans les variables d'environnement")
+    print("L'application démarrera mais les fonctionnalités de chat seront limitées")
+    client = None
+else:
+    try:
+        client = genai.Client(api_key=API_KEY)
+        print("Client Gemini initialisé avec succès")
+    except Exception as e:
+        print(f"ERREUR lors de l'initialisation du client Gemini: {e}")
+        client = None
 
 # Configuration par défaut
 MODEL = "gemini-2.5-flash"
@@ -43,8 +53,7 @@ DEFAULT_CONFIG = {
 # Outils activés par défaut
 DEFAULT_TOOLS = [
     types.Tool(code_execution=types.ToolCodeExecution()),
-    types.Tool(google_search=types.GoogleSearch()),
-    types.Tool(url_context=types.UrlContext())
+    types.Tool(google_search=types.GoogleSearch())
 ]
 
 # Stockage des conversations avec métadonnées (en production, utilisez une base de données)
@@ -122,25 +131,30 @@ def get_conversations():
 @app.route('/chat', methods=['POST'])
 def chat():
     try:
+        if not client:
+            return jsonify({'error': 'Client Gemini non initialisé. Vérifiez GOOGLE_API_KEY.'}), 500
+
         data = request.get_json()
         message = data.get('message', '')
         thinking_enabled = data.get('thinking_enabled', True)
         conversation_id = data.get('conversation_id', 'default')
-        
+
+        print(f"Requête chat reçue: message='{message[:50]}...', conversation_id={conversation_id}")
+
         # Ajouter le message de l'utilisateur à l'historique
         add_message_to_history(conversation_id, 'user', message)
-        
+
         # Configuration du thinking
         config_dict = DEFAULT_CONFIG.copy()
         config_dict["system_instruction"] = SYSTEM_INSTRUCTION
         config_dict["tools"] = DEFAULT_TOOLS
 
-        # Thinking not supported for chat API
-        # if thinking_enabled:
-        #     config_dict["thinking_config"] = types.ThinkingConfig(
-        #         thinking_budget=-1,  # Dynamic thinking
-        #         include_thoughts=True
-        #     )
+        # Activer thinking si demandé
+        if thinking_enabled:
+            config_dict["thinking_config"] = types.ThinkingConfig(
+                thinking_budget=-1,  # Dynamic thinking
+                include_thoughts=True
+            )
         generation_config = types.GenerateContentConfig(**config_dict)
         
         # Gestion de la conversation
@@ -155,15 +169,23 @@ def chat():
         # Génération de la réponse avec streaming
         def generate():
             try:
+                if not client:
+                    yield f"data: {json.dumps({'type': 'error', 'content': 'API Gemini non configurée. Définissez GOOGLE_API_KEY.'})}\n\n"
+                    return
+
+                print(f"Démarrage du streaming pour conversation {conversation_id}")
                 response_stream = chat.send_message_stream(
                     message,
                     config=generation_config
                 )
-                
+
                 full_response = ""
                 thoughts = ""
+                chunk_count = 0
 
                 for chunk in response_stream:
+                    chunk_count += 1
+                    print(f"Chunk {chunk_count} reçu")
                     for part in chunk.candidates[0].content.parts:
                         if part.text:
                             if part.thought and thinking_enabled:
@@ -172,15 +194,18 @@ def chat():
                             full_response += part.text
                             yield f"data: {json.dumps({'type': 'text', 'content': part.text})}\n\n"
 
+                print(f"Streaming terminé, réponse complète: {len(full_response)} caractères")
+
                 # Ajouter la réponse de l'assistant à l'historique
                 if full_response:
                     add_message_to_history(conversation_id, 'assistant', full_response)
-                
+
                 # Signal de fin
                 yield f"data: {json.dumps({'type': 'end'})}\n\n"
-                
+
             except Exception as e:
-                yield f"data: {json.dumps({'type': 'error', 'content': str(e)})}\n\n"
+                print(f"ERREUR lors du streaming: {e}")
+                yield f"data: {json.dumps({'type': 'error', 'content': f'Erreur API: {str(e)}'})}\n\n"
         
         return Response(generate(), mimetype='text/plain')
         
@@ -216,12 +241,17 @@ def upload_file():
 @app.route('/chat_with_file', methods=['POST'])
 def chat_with_file():
     try:
+        if not client:
+            return jsonify({'error': 'Client Gemini non initialisé. Vérifiez GOOGLE_API_KEY.'}), 500
+
         data = request.get_json()
         message = data.get('message', '')
         file_data_list = data.get('file_data', [])
         thinking_enabled = data.get('thinking_enabled', True)
         conversation_id = data.get('conversation_id', 'default')
 
+        print(f"Requête chat_with_file reçue: message='{message[:50]}...', fichiers={len(file_data_list)}, conversation_id={conversation_id}")
+
         # Ensure file_data_list is a list
         if not isinstance(file_data_list, list):
             file_data_list = [file_data_list]
@@ -232,18 +262,18 @@ def chat_with_file():
             file_count = len(file_data_list)
             display_message += f" [{file_count} fichier{'s' if file_count > 1 else ''}]"
         add_message_to_history(conversation_id, 'user', display_message, has_file=len(file_data_list) > 0, file_data=file_data_list)
-        
+
         # Configuration du thinking
         config_dict = DEFAULT_CONFIG.copy()
         config_dict["tools"] = DEFAULT_TOOLS
         config_dict["system_instruction"] = SYSTEM_INSTRUCTION
 
-        # Thinking not supported for chat API
-        # if thinking_enabled:
-        #     config_dict["thinking_config"] = types.ThinkingConfig(
-        #         thinking_budget=-1,
-        #         include_thoughts=True
-        #     )
+        # Activer thinking si demandé
+        if thinking_enabled:
+            config_dict["thinking_config"] = types.ThinkingConfig(
+                thinking_budget=-1,
+                include_thoughts=True
+            )
         generation_config = types.GenerateContentConfig(**config_dict)
         
         # Gestion de la conversation
@@ -269,15 +299,23 @@ def chat_with_file():
         # Génération de la réponse avec streaming
         def generate():
             try:
+                if not client:
+                    yield f"data: {json.dumps({'type': 'error', 'content': 'API Gemini non configurée. Définissez GOOGLE_API_KEY.'})}\n\n"
+                    return
+
+                print(f"Démarrage du streaming avec fichiers pour conversation {conversation_id}")
                 response_stream = chat.send_message_stream(
                     contents,
                     config=generation_config
                 )
-                
+
                 full_response = ""
                 thoughts = ""
+                chunk_count = 0
 
                 for chunk in response_stream:
+                    chunk_count += 1
+                    print(f"Chunk {chunk_count} reçu (avec fichiers)")
                     for part in chunk.candidates[0].content.parts:
                         if part.text:
                             if part.thought and thinking_enabled:
@@ -286,14 +324,18 @@ def chat_with_file():
                             full_response += part.text
                             yield f"data: {json.dumps({'type': 'text', 'content': part.text})}\n\n"
 
+                print(f"Streaming avec fichiers terminé, réponse complète: {len(full_response)} caractères")
+
                 # Ajouter la réponse de l'assistant à l'historique
                 if full_response:
                     add_message_to_history(conversation_id, 'assistant', full_response)
-                
+
+                # Signal de fin
                 yield f"data: {json.dumps({'type': 'end'})}\n\n"
-                
+
             except Exception as e:
-                yield f"data: {json.dumps({'type': 'error', 'content': str(e)})}\n\n"
+                print(f"ERREUR lors du streaming avec fichiers: {e}")
+                yield f"data: {json.dumps({'type': 'error', 'content': f'Erreur API avec fichiers: {str(e)}'})}\n\n"
         
         return Response(generate(), mimetype='text/plain')
         
@@ -357,21 +399,21 @@ def get_admin_stats():
         # Statistiques générales
         total_conversations = len(conversation_metadata)
         total_messages = sum(len(conv['messages']) for conv in conversation_metadata.values())
-        
+
         # Statistiques par statut
         status_stats = {}
         for conv in conversation_metadata.values():
             status = conv.get('status', 'active')
             status_stats[status] = status_stats.get(status, 0) + 1
-        
+
         # Conversations avec fichiers
-        conversations_with_files = sum(1 for conv in conversation_metadata.values() 
+        conversations_with_files = sum(1 for conv in conversation_metadata.values()
                                      if any(msg.get('hasFile') for msg in conv['messages']))
-        
+
         # Activité par jour (derniers 7 jours)
         from collections import defaultdict
         daily_activity = defaultdict(int)
-        
+
         for conv in conversation_metadata.values():
             for message in conv['messages']:
                 if message.get('timestamp'):
@@ -380,7 +422,7 @@ def get_admin_stats():
                         daily_activity[date.isoformat()] += 1
                     except:
                         continue
-        
+
         return jsonify({
             'total_conversations': total_conversations,
             'total_messages': total_messages,
@@ -391,5 +433,41 @@ def get_admin_stats():
     except Exception as e:
         return jsonify({'error': str(e)}), 500
 
+@app.route('/debug/api_test')
+def debug_api_test():
+    """Endpoint de debug pour tester la connectivité API"""
+    try:
+        if not client:
+            return jsonify({
+                'status': 'error',
+                'message': 'Client Gemini non initialisé',
+                'api_key_set': bool(API_KEY)
+            })
+
+        # Test simple de l'API
+        response = client.models.generate_content(
+            model=MODEL,
+            contents="Hello",
+            config=types.GenerateContentConfig(
+                max_output_tokens=10,
+                system_instruction="Réponds brièvement."
+            )
+        )
+
+        return jsonify({
+            'status': 'success',
+            'message': 'API Gemini fonctionnelle',
+            'model': MODEL,
+            'response_length': len(response.text) if response.text else 0,
+            'sample_response': response.text[:100] if response.text else None
+        })
+
+    except Exception as e:
+        return jsonify({
+            'status': 'error',
+            'message': f'Erreur API: {str(e)}',
+            'api_key_set': bool(API_KEY)
+        })
+
 if __name__ == '__main__':
     app.run(debug=True, host='0.0.0.0', port=5000)