Create backend/main.py

backend/main.py

@@ -0,0 +1,209 @@
+import asyncio
+import logging
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Optional, Dict, Any
+import numpy as np
+from datetime import datetime
+import uvicorn
+
+# Importar módulos
+from solana_integration.diamond_token import DiamondTokenManager
+from triton_server.inference import TritonInferenceEngine
+from api.routes import router as api_router
+from database.models import init_db, SessionLocal
+from monitoring.metrics import MetricsCollector
+
+app = FastAPI(title="Diamond AI Platform", version="1.0.0")
+
+# Configurar CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Inicializar componentes
+diamond_token = DiamondTokenManager()
+inference_engine = TritonInferenceEngine()
+metrics = MetricsCollector()
+
+class InferenceRequest(BaseModel):
+    prompt: str
+    wallet_address: Optional[str] = None
+    max_tokens: int = 200
+    temperature: float = 0.7
+    use_diamond_tokens: bool = True
+
+class TrainingRequest(BaseModel):
+    dataset_path: str
+    epochs: int = 3
+    learning_rate: float = 1e-4
+    wallet_address: str
+
+@app.on_event("startup")
+async def startup_event():
+    """Inicializar la aplicación"""
+    await init_db()
+    await inference_engine.initialize()
+    await diamond_token.initialize()
+    
+    # Iniciar monitoreo
+    asyncio.create_task(metrics.collect_system_metrics())
+    
+    logging.info("🚀 Diamond AI Platform iniciada")
+
+@app.get("/")
+async def root():
+    return {
+        "name": "Diamond AI Platform",
+        "version": "1.0.0",
+        "token_address": "5zJo2GzYRgiZw5j3SBNpuqVcGok35kT3ADwsw74yJWV6",
+        "wizardlm_model": "QuixiAI/WizardLM-7B-Uncensored"
+    }
+
+@app.post("/inference")
+async def generate_text(request: InferenceRequest, background_tasks: BackgroundTasks):
+    """
+    Endpoint de inferencia que utiliza tokens DIAMANTE
+    """
+    try:
+        # Verificar tokens si se requiere
+        if request.use_diamond_tokens and request.wallet_address:
+            has_tokens = await diamond_token.check_balance(request.wallet_address)
+            if not has_tokens:
+                raise HTTPException(
+                    status_code=402, 
+                    detail="Tokens DIAMANTE insuficientes"
+                )
+            
+            # Deducción de tokens por uso
+            background_tasks.add_task(
+                diamond_token.deduct_tokens,
+                request.wallet_address,
+                amount=1  # 1 DIAMANTE por inferencia
+            )
+        
+        # Generar texto con Tritón
+        response = await inference_engine.generate(
+            prompt=request.prompt,
+            max_tokens=request.max_tokens,
+            temperature=request.temperature
+        )
+        
+        # Registrar métricas
+        await metrics.record_inference(
+            wallet=request.wallet_address,
+            prompt_length=len(request.prompt),
+            response_length=len(response)
+        )
+        
+        return {
+            "generated_text": response,
+            "tokens_used": len(response.split()),
+            "timestamp": datetime.utcnow().isoformat(),
+            "model": "WizardLM-7B-Uncensored"
+        }
+        
+    except Exception as e:
+        logging.error(f"Error en inferencia: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/train")
+async def train_model(request: TrainingRequest):
+    """
+    Endpoint para fine-tuning con recompensas en DIAMANTE
+    """
+    # Verificar suficientes tokens para entrenamiento
+    required_tokens = 100  # 100 DIAMANTE para entrenamiento
+    balance = await diamond_token.get_balance(request.wallet_address)
+    
+    if balance < required_tokens:
+        raise HTTPException(
+            status_code=402,
+            detail=f"Se requieren {required_tokens} tokens DIAMANTE"
+        )
+    
+    # Iniciar entrenamiento en segundo plano
+    async def train_and_reward():
+        try:
+            # Ejecutar entrenamiento con Megatron
+            training_result = await megatron_training.fine_tune(
+                dataset_path=request.dataset_path,
+                epochs=request.epochs,
+                learning_rate=request.learning_rate
+            )
+            
+            # Recompensar al usuario con tokens
+            if training_result["success"]:
+                reward = 50  # 50 DIAMANTE por contribución
+                await diamond_token.transfer(
+                    from_wallet="platform_vault",
+                    to_wallet=request.wallet_address,
+                    amount=reward
+                )
+                
+                # Guardar modelo entrenado
+                await save_trained_model(training_result["model_path"])
+                
+        except Exception as e:
+            logging.error(f"Error en entrenamiento: {e}")
+    
+    # Ejecutar en background
+    asyncio.create_task(train_and_reward())
+    
+    return {
+        "message": "Entrenamiento iniciado",
+        "wallet": request.wallet_address,
+        "required_tokens": required_tokens,
+        "estimated_time": "2-4 horas"
+    }
+
+@app.get("/token/balance/{wallet_address}")
+async def get_balance(wallet_address: str):
+    """Consultar balance de tokens DIAMANTE"""
+    balance = await diamond_token.get_balance(wallet_address)
+    return {
+        "wallet": wallet_address,
+        "balance": balance,
+        "token_address": "5zJo2GzYRgiZw5j3SBNpuqVcGok35kT3ADwsw74yJWV6",
+        "token_name": "DIAMANTE"
+    }
+
+@app.post("/token/transfer")
+async def transfer_tokens(
+    from_wallet: str,
+    to_wallet: str,
+    amount: float,
+    private_key: str  # En producción usar autenticación segura
+):
+    """Transferir tokens DIAMANTE"""
+    try:
+        tx_signature = await diamond_token.transfer(
+            from_wallet=from_wallet,
+            to_wallet=to_wallet,
+            amount=amount,
+            private_key=private_key
+        )
+        
+        return {
+            "success": True,
+            "tx_signature": tx_signature,
+            "from": from_wallet,
+            "to": to_wallet,
+            "amount": amount
+        }
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=True,
+        log_level="info"
+    )