Upload app/api/main.py with huggingface_hub

app/api/main.py

@@ -0,0 +1,889 @@
+"""
+API Blueprint
+Main API routes for ContextFlow Research
+"""
+
+from flask import Blueprint, request, jsonify
+from ..agents.study_orchestrator import StudyOrchestrator
+from ..agents.doubt_predictor import DoubtPredictorAgent
+from ..agents.behavioral_agent import BehavioralAgent
+from ..agents.knowledge_graph_agent import KnowledgeGraphAgent
+from ..agents.recall_agent import RecallAgent
+from ..agents.peer_learning_agent import PeerLearningAgent
+from ..agents.hand_gesture_agent import HandGestureAgent, GestureSignalMapper
+from datetime import datetime
+import uuid
+
+api = Blueprint('api', __name__)
+
+orchestrators = {}
+gesture_agents = {}
+gesture_mappers = {}
+
+
+def get_orchestrator(user_id: str) -> StudyOrchestrator:
+    """Get or create orchestrator for user"""
+    if user_id not in orchestrators:
+        orchestrators[user_id] = StudyOrchestrator(user_id)
+    return orchestrators[user_id]
+
+
+@api.route('/session/start', methods=['POST'])
+def start_session():
+    """Start a new learning session"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    topic = data.get('topic', 'General')
+    subtopic = data.get('subtopic', '')
+    
+    orchestrator = get_orchestrator(user_id)
+    session = orchestrator.start_session(topic, subtopic)
+    
+    return jsonify({
+        'session_id': session.session_id,
+        'topic': topic,
+        'predictions': [
+            {
+                'doubt': p.predicted_doubt,
+                'confidence': p.confidence,
+                'explanation': p.suggested_explanation,
+                'priority': p.priority
+            }
+            for p in session.predictions
+        ],
+        'pending_reviews': len(orchestrator.state.pending_recalls),
+        'peer_insights_count': len(orchestrator.state.peer_insights)
+    })
+
+
+@api.route('/session/update', methods=['POST'])
+def update_session():
+    """Update session with behavioral data"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    behavioral_data = data.get('behavioral_data', {})
+    captured_doubt = data.get('captured_doubt')
+    
+    orchestrator = get_orchestrator(user_id)
+    orchestrator.update_session(behavioral_data, captured_doubt)
+    
+    return jsonify({
+        'status': 'updated',
+        'active_predictions': orchestrator.state.active_predictions[-3:],
+        'confusion_level': orchestrator.behavioral_agent.calculate_confusion_score(
+            orchestrator.state.current_session.behavioral_signals[-5:]
+        ) if orchestrator.state.current_session else 0
+    })
+
+
+@api.route('/session/end', methods=['POST'])
+def end_session():
+    """End learning session"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    
+    orchestrator = get_orchestrator(user_id)
+    summary = orchestrator.end_session()
+    
+    return jsonify(summary)
+
+
+@api.route('/session/insights', methods=['GET'])
+def get_insights():
+    """Get current session insights"""
+    user_id = request.args.get('user_id', 'anonymous')
+    
+    orchestrator = get_orchestrator(user_id)
+    insights = orchestrator.get_active_insights()
+    
+    return jsonify(insights)
+
+
+@api.route('/predict/doubts', methods=['POST'])
+def predict_doubts():
+    """Predict doubts for learning context"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    context = data.get('context', {})
+    
+    agent = DoubtPredictorAgent(user_id)
+    predictions = agent.predict_doubts(context, top_k=5)
+    
+    return jsonify({
+        'predictions': [
+            {
+                'doubt': p.predicted_doubt,
+                'confidence': p.confidence,
+                'explanation': p.suggested_explanation,
+                'related_concepts': p.related_concepts,
+                'priority': p.priority,
+                'estimated_time': p.estimated_resolution_time,
+                'prerequisites': p.prerequisite_topics
+            }
+            for p in predictions
+        ]
+    })
+
+
+@api.route('/recommendations', methods=['POST'])
+def get_recommendations():
+    """Get learning recommendations"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    context = data.get('context', {})
+    
+    agent = DoubtPredictorAgent(user_id)
+    recommendations = agent.get_learning_recommendations(context)
+    
+    return jsonify(recommendations)
+
+
+@api.route('/behavior/track', methods=['POST'])
+def track_behavior():
+    """Track behavioral signals"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    signals = data.get('signals', {})
+    
+    agent = BehavioralAgent(user_id)
+    processed = agent.process_signals(signals)
+    
+    confusion = agent.calculate_confusion_score(processed)
+    
+    return jsonify({
+        'signals_processed': len(processed),
+        'confusion_score': confusion,
+        'should_capture_doubt': confusion > 0.7,
+        'summary': agent.get_behavior_summary()
+    })
+
+
+@api.route('/behavior/heatmap', methods=['GET'])
+def get_heatmap():
+    """Get heatmap data"""
+    user_id = request.args.get('user_id', 'anonymous')
+    
+    agent = BehavioralAgent(user_id)
+    heatmap = agent.generate_heatmap_data()
+    
+    return jsonify({
+        'heatmap': heatmap
+    })
+
+
+@api.route('/graph/add', methods=['POST'])
+def add_to_graph():
+    """Add doubt to knowledge graph"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    doubt_data = data.get('doubt', {})
+    
+    agent = KnowledgeGraphAgent(user_id)
+    node = agent.add_doubt_to_graph(doubt_data)
+    
+    return jsonify({
+        'node_id': node.node_id,
+        'type': node.node_type,
+        'label': node.label
+    })
+
+
+@api.route('/graph/query', methods=['POST'])
+def query_graph():
+    """Query knowledge graph"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    query = data.get('query', '')
+    top_k = data.get('top_k', 5)
+    
+    agent = KnowledgeGraphAgent(user_id)
+    results = agent.graphrag_retrieve(query, top_k)
+    
+    return jsonify({
+        'results': results
+    })
+
+
+@api.route('/graph/stats', methods=['GET'])
+def get_graph_stats():
+    """Get graph statistics"""
+    user_id = request.args.get('user_id', 'anonymous')
+    
+    agent = KnowledgeGraphAgent(user_id)
+    stats = agent.get_graph_stats()
+    
+    return jsonify(stats)
+
+
+@api.route('/graph/path', methods=['GET'])
+def find_learning_path():
+    """Find learning path between topics"""
+    from_topic = request.args.get('from', '')
+    to_topic = request.args.get('to', '')
+    user_id = request.args.get('user_id', 'anonymous')
+    
+    agent = KnowledgeGraphAgent(user_id)
+    path = agent.find_learning_path(from_topic, to_topic)
+    
+    return jsonify({
+        'path': path,
+        'steps': len(path)
+    })
+
+
+@api.route('/review/due', methods=['GET'])
+def get_due_reviews():
+    """Get cards due for review"""
+    user_id = request.args.get('user_id', 'anonymous')
+    topic = request.args.get('topic')
+    
+    agent = RecallAgent(user_id)
+    recalls = agent.get_due_recalls(topic)
+    
+    return jsonify({
+        'due_count': len(recalls),
+        'cards': [
+            {
+                'card_id': c.card_id,
+                'front': c.front,
+                'back': c.back,
+                'topic': c.topic,
+                'interval': c.interval,
+                'ease_factor': c.ease_factor
+            }
+            for c in recalls[:20]
+        ]
+    })
+
+
+@api.route('/review/complete', methods=['POST'])
+def complete_review():
+    """Complete a review"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    card_id = data.get('card_id')
+    quality = data.get('quality', 3)
+    
+    agent = RecallAgent(user_id)
+    result = agent.complete_review(card_id, quality)
+    
+    if result:
+        return jsonify({
+            'card_id': result.card_id,
+            'quality': result.quality,
+            'xp_earned': result.xp_earned,
+            'next_interval': result.new_interval,
+            'next_review': result.next_review.isoformat()
+        })
+    
+    return jsonify({'error': 'Card not found'}), 404
+
+
+@api.route('/review/stats', methods=['GET'])
+def get_review_stats():
+    """Get review statistics"""
+    user_id = request.args.get('user_id', 'anonymous')
+    
+    agent = RecallAgent(user_id)
+    stats = agent.get_review_stats()
+    progress = agent.get_learning_progress()
+    
+    return jsonify({
+        'stats': stats,
+        'progress': progress
+    })
+
+
+@api.route('/peer/insights', methods=['GET'])
+def get_peer_insights():
+    """Get peer insights"""
+    topic = request.args.get('topic', 'General')
+    
+    agent = PeerLearningAgent('anonymous')
+    insights = agent.get_peer_insights(topic)
+    
+    return jsonify({
+        'insights': [
+            {
+                'type': i.insight_type,
+                'content': i.content,
+                'related_topics': i.related_topics,
+                'confidence': i.confidence,
+                'peer_count': i.peer_count
+            }
+            for i in insights
+        ]
+    })
+
+
+@api.route('/peer/doubts', methods=['GET'])
+def get_peer_doubts():
+    """Get peer doubts"""
+    topic = request.args.get('topic', 'General')
+    limit = int(request.args.get('limit', 10))
+    
+    agent = PeerLearningAgent('anonymous')
+    doubts = agent.get_peer_doubts(topic, limit)
+    
+    return jsonify({
+        'doubts': [
+            {
+                'id': d.doubt_id,
+                'content': d.content,
+                'resolved': d.resolved,
+                'upvotes': d.upvotes,
+                'similarity': d.similarity_score
+            }
+            for d in doubts
+        ]
+    })
+
+
+@api.route('/peer/trending', methods=['GET'])
+def get_trending():
+    """Get trending topics"""
+    agent = PeerLearningAgent('anonymous')
+    trending = agent.get_trending_topics()
+    
+    return jsonify({
+        'trending': trending
+    })
+
+
+@api.route('/health', methods=['GET'])
+def health():
+    """Health check"""
+    return jsonify({
+        'status': 'healthy',
+        'service': 'ContextFlow Research API',
+        'timestamp': datetime.now().isoformat(),
+        'active_sessions': len(orchestrators)
+    })
+
+
+# ===== Hand Gesture Training API =====
+
+def get_gesture_agent(user_id: str) -> HandGestureAgent:
+    """Get or create gesture agent for user"""
+    if user_id not in gesture_agents:
+        gesture_agents[user_id] = HandGestureAgent(user_id)
+    return gesture_agents[user_id]
+
+
+def get_gesture_mapper(user_id: str) -> GestureSignalMapper:
+    """Get or create gesture mapper for user"""
+    if user_id not in gesture_mappers:
+        gesture_mappers[user_id] = GestureSignalMapper()
+    return gesture_mappers[user_id]
+
+
+@api.route('/gesture/list', methods=['GET'])
+def list_gestures():
+    """List all available gestures"""
+    user_id = request.args.get('user_id', 'anonymous')
+    agent = get_gesture_agent(user_id)
+    gestures = agent.get_trained_gestures()
+    return jsonify({
+        'gestures': gestures,
+        'count': len(gestures)
+    })
+
+
+@api.route('/gesture/add', methods=['POST'])
+def add_gesture():
+    """Add a new custom gesture to train"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    name = data.get('name', 'Custom Gesture')
+    description = data.get('description', '')
+    gesture_type = data.get('type', 'custom')
+    
+    agent = get_gesture_agent(user_id)
+    gesture_id = agent.add_custom_gesture(name, description, gesture_type)
+    
+    return jsonify({
+        'gesture_id': gesture_id,
+        'name': name,
+        'message': f"Added '{name}'. Start training to teach the model."
+    })
+
+
+@api.route('/gesture/training/start', methods=['POST'])
+def start_gesture_training():
+    """Start training a gesture"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    gesture_id = data.get('gesture_id')
+    
+    agent = get_gesture_agent(user_id)
+    result = agent.start_training(gesture_id)
+    
+    return jsonify(result)
+
+
+@api.route('/gesture/training/sample', methods=['POST'])
+def add_gesture_sample():
+    """Add a training sample (hand landmarks)"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    landmarks = data.get('landmarks', [])
+    
+    agent = get_gesture_agent(user_id)
+    result = agent.add_training_sample(landmarks)
+    
+    return jsonify(result)
+
+
+@api.route('/gesture/training/cancel', methods=['POST'])
+def cancel_gesture_training():
+    """Cancel current training"""
+    user_id = request.json.get('user_id', 'anonymous')
+    agent = get_gesture_agent(user_id)
+    agent.cancel_training()
+    return jsonify({'message': 'Training cancelled'})
+
+
+@api.route('/gesture/recognition/enable', methods=['POST'])
+def enable_gesture_recognition():
+    """Enable real-time gesture recognition"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    
+    agent = get_gesture_agent(user_id)
+    result = agent.enable_recognition()
+    
+    return jsonify(result)
+
+
+@api.route('/gesture/recognition/disable', methods=['POST'])
+def disable_gesture_recognition():
+    """Disable gesture recognition"""
+    user_id = request.json.get('user_id', 'anonymous')
+    agent = get_gesture_agent(user_id)
+    result = agent.disable_recognition()
+    return jsonify(result)
+
+
+@api.route('/gesture/recognize', methods=['POST'])
+def recognize_gesture():
+    """Recognize gesture from landmarks"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    landmarks = data.get('landmarks', [])
+    
+    agent = get_gesture_agent(user_id)
+    recognition = agent.recognize(landmarks)
+    
+    if recognition:
+        mapper = get_gesture_mapper(user_id)
+        signal = mapper.map_to_signal(recognition)
+        
+        return jsonify({
+            'recognized': True,
+            'gesture': {
+                'name': recognition.gesture_name,
+                'confidence': recognition.confidence,
+                'type': recognition.gesture_type
+            },
+            'signal': signal
+        })
+    
+    return jsonify({'recognized': False})
+
+
+@api.route('/gesture/delete', methods=['POST'])
+def delete_gesture():
+    """Delete a gesture"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    gesture_id = data.get('gesture_id')
+    
+    agent = get_gesture_agent(user_id)
+    result = agent.delete_gesture(gesture_id)
+    return jsonify(result)
+
+
+@api.route('/gesture/export', methods=['GET'])
+def export_gestures():
+    """Export gesture model"""
+    user_id = request.args.get('user_id', 'anonymous')
+    agent = get_gesture_agent(user_id)
+    model = agent.export_model()
+    return jsonify(model)
+
+
+@api.route('/gesture/import', methods=['POST'])
+def import_gestures():
+    """Import gesture model"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    model_data = data.get('model', {})
+    
+    agent = get_gesture_agent(user_id)
+    agent.import_model(model_data)
+    
+    return jsonify({'success': True, 'message': 'Gesture model imported'})
+
+
+# ===== LLM Flow API =====
+
+from ..agents.llm_orchestrator_agent import LLMOrchestrator, LLMRequest, LLMProvider
+from ..agents.gesture_action_agent import GestureActionMapper, RLLearningLoop, GestureAction
+from ..agents.prompt_agent import PromptAgent, AutoSubmitAgent
+
+llm_orchestrators = {}
+gesture_action_mappers = {}
+rl_loops = {}
+prompt_agents = {}
+auto_submit_agents = {}
+
+
+def get_llm_orchestrator(user_id: str) -> LLMOrchestrator:
+    """Get or create LLM orchestrator for user"""
+    if user_id not in llm_orchestrators:
+        llm_orchestrators[user_id] = LLMOrchestrator()
+    return llm_orchestrators[user_id]
+
+
+def get_gesture_action_mapper(user_id: str) -> GestureActionMapper:
+    """Get or create gesture action mapper for user"""
+    if user_id not in gesture_action_mappers:
+        gesture_action_mappers[user_id] = GestureActionMapper()
+    return gesture_action_mappers[user_id]
+
+
+def get_rl_loop(user_id: str) -> RLLearningLoop:
+    """Get or create RL learning loop for user"""
+    if user_id not in rl_loops:
+        rl_loops[user_id] = RLLearningLoop(user_id)
+    return rl_loops[user_id]
+
+
+def get_prompt_agent(user_id: str) -> PromptAgent:
+    """Get or create prompt agent for user"""
+    if user_id not in prompt_agents:
+        prompt_agents[user_id] = PromptAgent()
+    return prompt_agents[user_id]
+
+
+def get_auto_submit_agent(user_id: str) -> AutoSubmitAgent:
+    """Get or create auto submit agent for user"""
+    if user_id not in auto_submit_agents:
+        prompt_agent = get_prompt_agent(user_id)
+        auto_submit_agents[user_id] = AutoSubmitAgent(prompt_agent)
+    return auto_submit_agents[user_id]
+
+
+@api.route('/llm/query', methods=['POST'])
+def llm_query():
+    """Query LLM with prompt"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    prompt = data.get('prompt', '')
+    system_prompt = data.get('system_prompt', 'You are a helpful learning assistant.')
+    providers = data.get('providers', ['chatgpt', 'gemini'])
+    api_keys = data.get('api_keys', {})
+    models = data.get('models', {})
+    
+    llm_provider_map = {
+        'chatgpt': LLMProvider.CHATGPT,
+        'gemini': LLMProvider.GEMINI,
+        'claude': LLMProvider.CLAUDE,
+        'deepseek': LLMProvider.DEEPSEEK,
+        'ollama': LLMProvider.OLLAMA,
+        'groq': LLMProvider.GROQ
+    }
+    
+    provider_enums = [llm_provider_map.get(p, LLMProvider.CHATGPT) for p in providers]
+    
+    orchestrator = get_llm_orchestrator(user_id)
+    
+    for provider_name, api_key in api_keys.items():
+        if api_key:
+            orchestrator.api_keys[provider_name] = api_key
+    
+    for provider_name, model in models.items():
+        if provider_name in orchestrator.provider_configs:
+            config = orchestrator.provider_configs[provider_name]
+            if isinstance(config, dict):
+                config['model'] = model
+                config['model_name'] = model
+    
+    request_obj = LLMRequest(
+        prompt=prompt,
+        system_prompt=system_prompt,
+        providers=provider_enums,
+        user_id=user_id,
+        models=models
+    )
+    
+    responses = orchestrator.query_parallel(request_obj)
+    
+    return jsonify({
+        'responses': [
+            {
+                'provider': r.provider.value,
+                'content': r.content,
+                'success': r.success,
+                'error': r.error,
+                'latency_ms': r.latency_ms
+            }
+            for r in responses
+        ],
+        'rate_limits': orchestrator.get_rate_limit_status()
+    })
+
+
+@api.route('/llm/rate-limits', methods=['GET'])
+def get_rate_limits():
+    """Get current rate limit status"""
+    user_id = request.args.get('user_id', 'anonymous')
+    orchestrator = get_llm_orchestrator(user_id)
+    return jsonify(orchestrator.get_rate_limit_status())
+
+
+@api.route('/llm/gesture-action', methods=['POST'])
+def gesture_action():
+    """Process gesture and trigger LLM action"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    landmarks = data.get('landmarks', [])
+    context = data.get('context', {})
+    
+    mapper = get_gesture_action_mapper(user_id)
+    events = mapper.process_landmarks(landmarks, context)
+    
+    results = []
+    for event in events:
+        orchestrator = get_llm_orchestrator(user_id)
+        rl_loop = get_rl_loop(user_id)
+        executed_event = mapper.execute_action(event, orchestrator, rl_loop)
+        
+        results.append({
+            'action': executed_event.action.value,
+            'gesture': executed_event.gesture_name,
+            'confidence': executed_event.confidence,
+            'llm_responses': executed_event.llm_responses,
+            'rl_feedback': executed_event.rl_feedback
+        })
+    
+    return jsonify({
+        'events': results,
+        'available_actions': mapper.get_available_actions()
+    })
+
+
+@api.route('/llm/gesture-actions', methods=['GET'])
+def get_available_gesture_actions():
+    """Get available gesture actions"""
+    user_id = request.args.get('user_id', 'anonymous')
+    mapper = get_gesture_action_mapper(user_id)
+    return jsonify({
+        'actions': mapper.get_available_actions()
+    })
+
+
+@api.route('/llm/rl/start', methods=['POST'])
+def start_rl_loop():
+    """Start RL learning loop"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    context = data.get('context', {})
+    
+    rl_loop = get_rl_loop(user_id)
+    rl_loop.start_loop(context)
+    
+    return jsonify({
+        'status': 'started',
+        'user_id': user_id
+    })
+
+
+@api.route('/llm/rl/interact', methods=['POST'])
+def rl_interact():
+    """Add interaction to RL loop"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    action = data.get('action', '')
+    response = data.get('response', '')
+    
+    rl_loop = get_rl_loop(user_id)
+    rl_loop.add_interaction(action, response)
+    
+    return jsonify({
+        'status': 'recorded',
+        'total_interactions': len(rl_loop.conversation_history)
+    })
+
+
+@api.route('/llm/rl/feedback', methods=['POST'])
+def rl_feedback():
+    """Add feedback to RL loop"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    quality = data.get('quality', 3)
+    comment = data.get('comment')
+    
+    rl_loop = get_rl_loop(user_id)
+    rl_loop.add_feedback(quality, comment)
+    
+    return jsonify({
+        'status': 'feedback_recorded',
+        'average_reward': sum(rl_loop.reward_history) / len(rl_loop.reward_history) if rl_loop.reward_history else 0
+    })
+
+
+@api.route('/llm/rl/status', methods=['GET'])
+def get_rl_status():
+    """Get RL loop status"""
+    user_id = request.args.get('user_id', 'anonymous')
+    rl_loop = get_rl_loop(user_id)
+    return jsonify(rl_loop.get_status())
+
+
+@api.route('/llm/rl/end', methods=['POST'])
+def end_rl_loop():
+    """End RL learning loop"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    
+    rl_loop = get_rl_loop(user_id)
+    rl_loop.end_loop()
+    
+    return jsonify({
+        'status': 'ended',
+        'summary': rl_loop.get_status()
+    })
+
+
+@api.route('/llm/prompt/generate', methods=['POST'])
+def generate_prompt():
+    """Generate prompt from template"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    template = data.get('template', 'learning_explain')
+    context = data.get('context', {})
+    
+    prompt_agent = get_prompt_agent(user_id)
+    prompt_agent.update_context(context)
+    
+    prompt = prompt_agent.generate_prompt(template, context)
+    
+    return jsonify({
+        'prompt': prompt.content,
+        'template': prompt.template_used,
+        'llm_targets': prompt.llm_targets,
+        'auto_submit': prompt.auto_submit
+    })
+
+
+@api.route('/llm/prompt/from-gesture', methods=['POST'])
+def generate_prompt_from_gesture():
+    """Generate prompt based on gesture action"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    gesture = data.get('gesture', '')
+    context = data.get('context', {})
+    
+    prompt_agent = get_prompt_agent(user_id)
+    prompt = prompt_agent.generate_from_gesture(gesture, context)
+    
+    return jsonify({
+        'prompt': prompt.content,
+        'template': prompt.template_used,
+        'llm_targets': prompt.llm_targets,
+        'auto_submit': prompt.auto_submit
+    })
+
+
+@api.route('/llm/prompt/suggest', methods=['GET'])
+def suggest_prompts():
+    """Get suggested prompts based on context"""
+    user_id = request.args.get('user_id', 'anonymous')
+    context_str = request.args.get('context', '{}')
+    
+    import json
+    context = json.loads(context_str)
+    
+    prompt_agent = get_prompt_agent(user_id)
+    suggestions = prompt_agent.get_suggested_prompts(context)
+    
+    return jsonify({
+        'suggestions': [
+            {
+                'prompt': s.content,
+                'template': s.template_used,
+                'llm_targets': s.llm_targets
+            }
+            for s in suggestions
+        ]
+    })
+
+
+@api.route('/llm/auto-submit/prepare', methods=['POST'])
+def prepare_auto_submit():
+    """Prepare prompt for auto submission"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    prompt_content = data.get('prompt', '')
+    template = data.get('template')
+    
+    prompt_agent = get_prompt_agent(user_id)
+    from ..agents.prompt_agent import GeneratedPrompt
+    
+    prompt = GeneratedPrompt(
+        content=prompt_content,
+        template_used=template,
+        context={},
+        llm_targets=['chatgpt'],
+        auto_submit=True
+    )
+    
+    auto_submit = get_auto_submit_agent(user_id)
+    submission = auto_submit.prepare_submission(prompt)
+    
+    return jsonify({
+        'status': 'ready',
+        'submission_id': len(submission)
+    })
+
+
+@api.route('/llm/auto-submit/status', methods=['GET'])
+def get_auto_submit_status():
+    """Get auto submit status"""
+    user_id = request.args.get('user_id', 'anonymous')
+    auto_submit = get_auto_submit_agent(user_id)
+    return jsonify(auto_submit.get_submission_status())
+
+
+@api.route('/llm/gesture-training/swipe', methods=['POST'])
+def train_swipe_gesture():
+    """Train a swipe gesture"""
+    data = request.json
+    user_id = data.get('user_id', 'anonymous')
+    gesture_name = data.get('gesture_name', 'swipe_right')
+    action = data.get('action', 'query_multi_llm')
+    finger_count = data.get('finger_count', 2)
+    
+    mapper = get_gesture_action_mapper(user_id)
+    
+    gesture_pattern = {
+        'type': 'swipe',
+        'finger_count': finger_count,
+        'name': gesture_name
+    }
+    
+    action_enum = GestureAction(action) if action in [a.value for a in GestureAction] else GestureAction.CUSTOM
+    
+    mapper.add_custom_mapping(
+        name=gesture_name,
+        gesture_pattern=gesture_pattern,
+        action=action_enum,
+        parameters={'user_defined': True}
+    )
+    
+    return jsonify({
+        'success': True,
+        'gesture_name': gesture_name,
+        'action': action_enum.value
+    })