feat: implement chat interface with CrewAI integration

- Create MiniMax LLM connector for CrewAI integration
- Implement TradingCrew with trading_designer, strategy_validator, strategy_explainer
- Add strategy parsing from natural language to strategy_config JSON
- Update chat endpoint with CrewAI integration and conversation context
- Add strategy validation logic
- Add explanation generation for user-friendly responses
- Add BotChatRequest/BotChatResponse schemas

Fixes #6

src/backend/app/api/auth.py

@@ -1,7 +1,6 @@
-from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi import APIRouter, Depends, HTTPException, status, Request
 from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
 from sqlalchemy.orm import Session
-from datetime import timedelta
 from typing import Annotated
 
 from ..core.database import get_db
@@ -12,41 +11,133 @@ from ..core.security import (
     verify_token,
 )
 from ..core.config import get_settings
-from ..db.schemas import UserCreate, UserResponse, Token
+from ..core.limiter import limiter
+from ..db.schemas import (
+    UserCreate,
+    UserResponse,
+    Token,
+    UserSettings,
+    UserSettingsUpdate,
+)
+from ..db.models import User
 
 router = APIRouter()
 settings = get_settings()
-oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/auth/token")
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/auth/login")
+
+TOKEN_BLACKLIST = set()
 
 
-@router.post("/register", response_model=UserResponse)
+def get_current_user(
+    token: Annotated[str, Depends(oauth2_scheme)], db: Session = Depends(get_db)
+) -> User:
+    if token in TOKEN_BLACKLIST:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Token has been revoked",
+        )
+    payload = verify_token(token)
+    if payload is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid or expired token",
+        )
+    user_id = payload.get("sub")
+    if user_id is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid token payload",
+        )
+    user = db.query(User).filter(User.id == user_id).first()
+    if user is None:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="User not found",
+        )
+    return user
+
+
+@router.post(
+    "/register", response_model=UserResponse, status_code=status.HTTP_201_CREATED
+)
 def register(user: UserCreate, db: Session = Depends(get_db)):
-    raise HTTPException(
-        status_code=status.HTTP_501_NOT_IMPLEMENTED, detail="Not implemented"
+    existing_user = db.query(User).filter(User.email == user.email).first()
+    if existing_user:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Email already registered",
+        )
+    hashed_password = get_password_hash(user.password)
+    db_user = User(
+        email=user.email,
+        password_hash=hashed_password,
     )
+    db.add(db_user)
+    db.commit()
+    db.refresh(db_user)
+    return db_user
 
 
-@router.post("/login")
+@router.post("/login", response_model=Token)
+@limiter.limit("5/minute")
 def login(
+    request: Request,
     form_data: Annotated[OAuth2PasswordRequestForm, Depends()],
     db: Session = Depends(get_db),
 ):
-    raise HTTPException(
-        status_code=status.HTTP_501_NOT_IMPLEMENTED, detail="Not implemented"
-    )
+    user = db.query(User).filter(User.email == form_data.username).first()
+    if not user or not verify_password(form_data.password, user.password_hash):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect email or password",
+        )
+    access_token = create_access_token(data={"sub": user.id})
+    return Token(access_token=access_token, token_type="bearer")
 
 
 @router.post("/logout")
-def logout(token: Annotated[str, Depends(oauth2_scheme)]):
-    raise HTTPException(
-        status_code=status.HTTP_501_NOT_IMPLEMENTED, detail="Not implemented"
-    )
+def logout(
+    current_user: Annotated[User, Depends(get_current_user)],
+    token: Annotated[str, Depends(oauth2_scheme)],
+):
+    TOKEN_BLACKLIST.add(token)
+    return {"message": "Successfully logged out"}
 
 
 @router.get("/me", response_model=UserResponse)
 def get_me(
-    token: Annotated[str, Depends(oauth2_scheme)], db: Session = Depends(get_db)
+    current_user: Annotated[User, Depends(get_current_user)],
 ):
-    raise HTTPException(
-        status_code=status.HTTP_501_NOT_IMPLEMENTED, detail="Not implemented"
-    )
+    return current_user
+
+
+@router.get("/settings", response_model=UserSettings)
+def get_settings_endpoint(
+    current_user: Annotated[User, Depends(get_current_user)],
+):
+    return UserSettings(email=current_user.email)
+
+
+@router.patch("/settings", response_model=UserSettings)
+def update_settings(
+    current_user: Annotated[User, Depends(get_current_user)],
+    settings_update: UserSettingsUpdate,
+    db: Session = Depends(get_db),
+):
+    if settings_update.email:
+        existing = (
+            db.query(User)
+            .filter(User.email == settings_update.email, User.id != current_user.id)
+            .first()
+        )
+        if existing:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Email already in use",
+            )
+        current_user.email = settings_update.email
+    if settings_update.password:
+        current_user.password_hash = get_password_hash(settings_update.password)
+    db.commit()
+    db.refresh(current_user)
+    return UserSettings(email=current_user.email)

src/backend/app/api/bots.py

@@ -1,57 +1,275 @@
 from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.orm import Session
-from typing import List
+from typing import List, Annotated
 
+from .auth import get_current_user
 from ..core.database import get_db
-from ..db.schemas import BotCreate, BotUpdate, BotResponse
+from ..core.config import get_settings
+from ..db.schemas import (
+    BotCreate,
+    BotUpdate,
+    BotResponse,
+    BotConversationCreate,
+    BotConversationResponse,
+    BotChatRequest,
+    BotChatResponse,
+)
+from ..db.models import Bot, BotConversation, User
+from ..services.ai_agent.crew import get_trading_crew
 
 router = APIRouter()
+MAX_BOTS_PER_USER = 3
 
 
 @router.get("", response_model=List[BotResponse])
-def list_bots(db: Session = Depends(get_db)):
-    raise HTTPException(
-        status_code=status.HTTP_501_NOT_IMPLEMENTED, detail="Not implemented"
-    )
+def list_bots(
+    current_user: Annotated[User, Depends(get_current_user)],
+    db: Session = Depends(get_db),
+):
+    bots = db.query(Bot).filter(Bot.user_id == current_user.id).all()
+    return bots
 
 
-@router.post("", response_model=BotResponse)
-def create_bot(bot: BotCreate, db: Session = Depends(get_db)):
-    raise HTTPException(
-        status_code=status.HTTP_501_NOT_IMPLEMENTED, detail="Not implemented"
+@router.post("", response_model=BotResponse, status_code=status.HTTP_201_CREATED)
+def create_bot(
+    bot_data: BotCreate,
+    current_user: Annotated[User, Depends(get_current_user)],
+    db: Session = Depends(get_db),
+):
+    user_bot_count = db.query(Bot).filter(Bot.user_id == current_user.id).count()
+    if user_bot_count >= MAX_BOTS_PER_USER:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=f"Maximum of {MAX_BOTS_PER_USER} bots per user exceeded",
+        )
+
+    existing_bot = (
+        db.query(Bot)
+        .filter(Bot.user_id == current_user.id, Bot.name == bot_data.name)
+        .first()
     )
+    if existing_bot:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Bot name must be unique per user",
+        )
+
+    db_bot = Bot(
+        user_id=current_user.id,
+        name=bot_data.name,
+        description=bot_data.description,
+        strategy_config=bot_data.strategy_config,
+        llm_config=bot_data.llm_config,
+    )
+    db.add(db_bot)
+    db.commit()
+    db.refresh(db_bot)
+    return db_bot
 
 
 @router.get("/{bot_id}", response_model=BotResponse)
-def get_bot(bot_id: str, db: Session = Depends(get_db)):
-    raise HTTPException(
-        status_code=status.HTTP_501_NOT_IMPLEMENTED, detail="Not implemented"
-    )
+def get_bot(
+    bot_id: str,
+    current_user: Annotated[User, Depends(get_current_user)],
+    db: Session = Depends(get_db),
+):
+    bot = db.query(Bot).filter(Bot.id == bot_id).first()
+    if not bot:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Bot not found",
+        )
+    if bot.user_id != current_user.id:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Not authorized to access this bot",
+        )
+    return bot
 
 
 @router.put("/{bot_id}", response_model=BotResponse)
-def update_bot(bot_id: str, bot: BotUpdate, db: Session = Depends(get_db)):
-    raise HTTPException(
-        status_code=status.HTTP_501_NOT_IMPLEMENTED, detail="Not implemented"
+def update_bot(
+    bot_id: str,
+    bot_data: BotUpdate,
+    current_user: Annotated[User, Depends(get_current_user)],
+    db: Session = Depends(get_db),
+):
+    bot = db.query(Bot).filter(Bot.id == bot_id).first()
+    if not bot:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Bot not found",
+        )
+    if bot.user_id != current_user.id:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Not authorized to update this bot",
+        )
+
+    if bot_data.name is not None:
+        existing_bot = (
+            db.query(Bot)
+            .filter(
+                Bot.user_id == current_user.id,
+                Bot.name == bot_data.name,
+                Bot.id != bot_id,
+            )
+            .first()
+        )
+        if existing_bot:
+            raise HTTPException(
+                status_code=status.HTTP_400_BAD_REQUEST,
+                detail="Bot name must be unique per user",
+            )
+        bot.name = bot_data.name
+
+    if bot_data.description is not None:
+        bot.description = bot_data.description
+    if bot_data.strategy_config is not None:
+        bot.strategy_config = bot_data.strategy_config
+    if bot_data.llm_config is not None:
+        bot.llm_config = bot_data.llm_config
+    if bot_data.status is not None:
+        bot.status = bot_data.status
+
+    db.commit()
+    db.refresh(bot)
+    return bot
+
+
+@router.delete("/{bot_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_bot(
+    bot_id: str,
+    current_user: Annotated[User, Depends(get_current_user)],
+    db: Session = Depends(get_db),
+):
+    bot = db.query(Bot).filter(Bot.id == bot_id).first()
+    if not bot:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Bot not found",
+        )
+    if bot.user_id != current_user.id:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Not authorized to delete this bot",
+        )
+    db.delete(bot)
+    db.commit()
+
+
+@router.post("/{bot_id}/chat", response_model=BotChatResponse)
+def chat(
+    bot_id: str,
+    request: BotChatRequest,
+    current_user: Annotated[User, Depends(get_current_user)],
+    db: Session = Depends(get_db),
+):
+    bot = db.query(Bot).filter(Bot.id == bot_id).first()
+    if not bot:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Bot not found",
+        )
+    if bot.user_id != current_user.id:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Not authorized to chat with this bot",
+        )
+
+    conversation_history = (
+        db.query(BotConversation)
+        .filter(BotConversation.bot_id == bot_id)
+        .order_by(BotConversation.created_at)
+        .all()
     )
+    history_for_crew = [
+        {"role": conv.role, "content": conv.content}
+        for conv in conversation_history[-10:]
+    ]
+
+    user_message = request.message
+    if request.strategy_config:
+        crew = get_trading_crew()
+        result = crew.chat(user_message, history_for_crew)
+
+        assistant_content = result.get("response", "I couldn't process your request.")
+        if result.get("success") and result.get("strategy_config"):
+            bot.strategy_config = result["strategy_config"]
+            db.commit()
+
+        db_conversation = BotConversation(
+            bot_id=bot_id,
+            role="user",
+            content=user_message,
+        )
+        db.add(db_conversation)
+
+        db_assistant = BotConversation(
+            bot_id=bot_id,
+            role="assistant",
+            content=assistant_content,
+        )
+        db.add(db_assistant)
+        db.commit()
+        db.refresh(db_assistant)
+
+        return BotChatResponse(
+            response=assistant_content,
+            strategy_config=result.get("strategy_config"),
+            success=result.get("success", False),
+        )
+    else:
+        crew = get_trading_crew()
+        result = crew.chat(user_message, history_for_crew)
+
+        assistant_content = result.get("response", "I couldn't process your request.")
+
+        db_conversation = BotConversation(
+            bot_id=bot_id,
+            role="user",
+            content=user_message,
+        )
+        db.add(db_conversation)
+
+        db_assistant = BotConversation(
+            bot_id=bot_id,
+            role="assistant",
+            content=assistant_content,
+        )
+        db.add(db_assistant)
+        db.commit()
+        db.refresh(db_assistant)
+
+        return BotChatResponse(
+            response=assistant_content,
+            strategy_config=result.get("strategy_config"),
+            success=result.get("success", False),
+        )
 
 
-@router.delete("/{bot_id}")
-def delete_bot(bot_id: str, db: Session = Depends(get_db)):
-    raise HTTPException(
-        status_code=status.HTTP_501_NOT_IMPLEMENTED, detail="Not implemented"
-    )
-
-
-@router.post("/{bot_id}/chat")
-def chat(bot_id: str, message: dict, db: Session = Depends(get_db)):
-    raise HTTPException(
-        status_code=status.HTTP_501_NOT_IMPLEMENTED, detail="Not implemented"
-    )
-
-
-@router.get("/{bot_id}/history")
-def get_history(bot_id: str, db: Session = Depends(get_db)):
-    raise HTTPException(
-        status_code=status.HTTP_501_NOT_IMPLEMENTED, detail="Not implemented"
+@router.get("/{bot_id}/history", response_model=List[BotConversationResponse])
+def get_history(
+    bot_id: str,
+    current_user: Annotated[User, Depends(get_current_user)],
+    db: Session = Depends(get_db),
+):
+    bot = db.query(Bot).filter(Bot.id == bot_id).first()
+    if not bot:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Bot not found",
+        )
+    if bot.user_id != current_user.id:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Not authorized to access this bot's history",
+        )
+
+    conversations = (
+        db.query(BotConversation)
+        .filter(BotConversation.bot_id == bot_id)
+        .order_by(BotConversation.created_at)
+        .all()
     )
+    return conversations

src/backend/app/core/limiter.py

@@ -0,0 +1,4 @@
+from slowapi import Limiter
+from slowapi.util import get_remote_address
+
+limiter = Limiter(key_func=get_remote_address)

src/backend/app/db/schemas.py

@@ -23,6 +23,15 @@ class Token(BaseModel):
     token_type: str
 
 
+class UserSettings(BaseModel):
+    email: EmailStr
+
+
+class UserSettingsUpdate(BaseModel):
+    email: Optional[EmailStr] = None
+    password: Optional[str] = None
+
+
 class BotCreate(BaseModel):
     name: str
     description: Optional[str] = None
@@ -91,3 +100,46 @@ class SimulationResponse(BaseModel):
 
     class Config:
         from_attributes = True
+
+
+class BotConversationCreate(BaseModel):
+    role: str
+    content: str
+
+
+class BotConversationResponse(BaseModel):
+    id: str
+    bot_id: str
+    role: str
+    content: str
+    created_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class BotChatRequest(BaseModel):
+    message: str
+    strategy_config: Optional[bool] = False
+
+
+class BotChatResponse(BaseModel):
+    response: str
+    strategy_config: Optional[dict] = None
+    success: bool = False
+
+
+class SignalResponse(BaseModel):
+    id: str
+    bot_id: str
+    run_id: str
+    signal_type: str
+    token: str
+    price: float
+    confidence: Optional[float]
+    reasoning: Optional[str]
+    executed: bool
+    created_at: datetime
+
+    class Config:
+        from_attributes = True

src/backend/app/main.py

@@ -1,6 +1,9 @@
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
+from slowapi import Limiter
+from slowapi.util import get_remote_address
 from .api import auth, bots, backtest, simulate, config
+from .core.limiter import limiter
 
 app = FastAPI(
     title="Randebu Trading Bot API",
@@ -8,6 +11,8 @@ app = FastAPI(
     version="0.1.0",
 )
 
+app.state.limiter = limiter
+
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],

src/backend/app/services/ai_agent/crew.py

@@ -1,15 +1,247 @@
-from typing import List, Optional
+from typing import List, Optional, Dict, Any
+from crewai import Agent, Task, Crew
+from .llm_connector import MiniMaxConnector, MiniMaxLLM
+from ..core.config import get_settings
 
 
-class CrewAgent:
-    def __init__(self, role: str, goal: str, backstory: str):
-        self.role = role
-        self.goal = goal
-        self.backstory = backstory
+class StrategyValidator:
+    SUPPORTED_CONDITIONS = ["price_drop", "price_rise", "volume_spike", "price_level"]
+    SUPPORTED_ACTIONS = ["buy", "sell", "notify"]
 
-    def execute_task(self, task: str) -> str:
-        raise NotImplementedError("CrewAI agent not yet implemented")
+    def validate(self, strategy_config: dict) -> tuple[bool, list[str]]:
+        errors = []
+
+        if "conditions" not in strategy_config:
+            errors.append("Missing 'conditions' in strategy config")
+            return False, errors
+
+        if not isinstance(strategy_config["conditions"], list):
+            errors.append("'conditions' must be a list")
+            return False, errors
+
+        if len(strategy_config["conditions"]) == 0:
+            errors.append("At least one condition is required")
+            return False, errors
+
+        for i, condition in enumerate(strategy_config["conditions"]):
+            if "type" not in condition:
+                errors.append(f"Condition {i}: missing 'type'")
+                continue
+
+            cond_type = condition.get("type")
+            if cond_type not in self.SUPPORTED_CONDITIONS:
+                errors.append(f"Condition {i}: unsupported type '{cond_type}'")
+                continue
+
+            params = condition.get("params", {})
+            if cond_type in ["price_drop", "price_rise", "volume_spike"]:
+                if "token" not in params:
+                    errors.append(f"Condition {i}: missing 'token'")
+                if "threshold_percent" not in params:
+                    errors.append(f"Condition {i}: missing 'threshold_percent'")
+                elif not isinstance(params["threshold_percent"], (int, float)):
+                    errors.append(
+                        f"Condition {i}: 'threshold_percent' must be a number"
+                    )
+                elif params["threshold_percent"] <= 0:
+                    errors.append(
+                        f"Condition {i}: 'threshold_percent' must be positive"
+                    )
+
+            elif cond_type == "price_level":
+                if "token" not in params:
+                    errors.append(f"Condition {i}: missing 'token'")
+                if "price" not in params:
+                    errors.append(f"Condition {i}: missing 'price'")
+                if "direction" not in params:
+                    errors.append(f"Condition {i}: missing 'direction'")
+                elif params["direction"] not in ["above", "below"]:
+                    errors.append(
+                        f"Condition {i}: direction must be 'above' or 'below'"
+                    )
+
+        if "actions" in strategy_config:
+            if not isinstance(strategy_config["actions"], list):
+                errors.append("'actions' must be a list")
+            else:
+                for i, action in enumerate(strategy_config["actions"]):
+                    if "type" not in action:
+                        errors.append(f"Action {i}: missing 'type'")
+                    elif action["type"] not in self.SUPPORTED_ACTIONS:
+                        errors.append(
+                            f"Action {i}: unsupported type '{action['type']}'"
+                        )
+
+        return len(errors) == 0, errors
 
 
-def get_trading_crew():
-    raise NotImplementedError("Trading crew not yet implemented")
+class StrategyExplainer:
+    def explain(self, strategy_config: dict) -> str:
+        explanations = []
+
+        if "conditions" in strategy_config:
+            cond_list = strategy_config["conditions"]
+            if cond_list:
+                explanations.append("This strategy will trigger when:")
+                for cond in cond_list:
+                    cond_type = cond.get("type")
+                    params = cond.get("params", {})
+                    token = params.get("token", "the token")
+
+                    if cond_type == "price_drop":
+                        pct = params.get("threshold_percent", 0)
+                        explanations.append(f"  - {token} price drops by {pct}%")
+                    elif cond_type == "price_rise":
+                        pct = params.get("threshold_percent", 0)
+                        explanations.append(f"  - {token} price rises by {pct}%")
+                    elif cond_type == "volume_spike":
+                        pct = params.get("threshold_percent", 0)
+                        explanations.append(
+                            f"  - {token} trading volume increases by {pct}%"
+                        )
+                    elif cond_type == "price_level":
+                        price = params.get("price", 0)
+                        direction = params.get("direction", "unknown")
+                        explanations.append(
+                            f"  - {token} price crosses {direction} ${price}"
+                        )
+
+        if "actions" in strategy_config:
+            actions = strategy_config.get("actions", [])
+            if actions:
+                explanations.append("\nWhen triggered, the strategy will:")
+                for action in actions:
+                    action_type = action.get("type")
+                    if action_type == "buy":
+                        explanations.append("  - Buy the token")
+                    elif action_type == "sell":
+                        explanations.append("  - Sell the token")
+                    elif action_type == "notify":
+                        explanations.append("  - Send a notification")
+
+        if not explanations:
+            explanations.append("Strategy configuration is empty or invalid.")
+
+        return "\n".join(explanations)
+
+
+def create_trading_designer_agent(
+    api_key: str, model: str = "MiniMax-Text-01"
+) -> Agent:
+    connector = MiniMaxConnector(api_key=api_key, model=model)
+
+    system_prompt = """You are a Trading Strategy Designer AI. Your role is to parse user requests 
+    for trading strategies into structured JSON configuration.
+
+    Supported conditions (MVP):
+    - price_drop: Triggers when a token's price drops by a specified percentage
+    - price_rise: Triggers when a token's price rises by a specified percentage
+    - volume_spike: Triggers when trading volume increases by a specified percentage
+    - price_level: Triggers when price crosses above or below a specified level
+
+    Always ask clarifying questions if the user's request is ambiguous.
+    Output strategy_config in valid JSON format only when you have all required information.
+    """
+
+    return Agent(
+        role="Trading Strategy Designer",
+        goal="Convert natural language trading requests into precise strategy configurations",
+        backstory=system_prompt,
+        llm=MiniMaxLLM(api_key=api_key, model=model),
+        verbose=True,
+    )
+
+
+def create_strategy_validator_agent(
+    api_key: str, model: str = "MiniMax-Text-01"
+) -> Agent:
+    return Agent(
+        role="Strategy Validator",
+        goal="Validate trading strategy configurations for feasibility and identify potential issues",
+        backstory="""You are a meticulous strategy validator with expertise in trading systems.
+        You check that all required parameters are present, values are reasonable, and the 
+        strategy makes logical sense. You never approve strategies with missing or invalid data.""",
+        llm=MiniMaxLLM(api_key=api_key, model=model),
+        verbose=True,
+    )
+
+
+def create_strategy_explainer_agent(
+    api_key: str, model: str = "MiniMax-Text-01"
+) -> Agent:
+    return Agent(
+        role="Strategy Explainer",
+        goal="Generate clear, user-friendly explanations of trading strategies",
+        backstory="""You are a patient trading strategy explainer. You translate complex 
+        strategy configurations into easy-to-understand language. You help users understand 
+        exactly what their strategies will do when triggered.""",
+        llm=MiniMaxLLM(api_key=api_key, model=model),
+        verbose=True,
+    )
+
+
+class TradingCrew:
+    def __init__(self, api_key: str, model: str = "MiniMax-Text-01"):
+        self.api_key = api_key
+        self.model = model
+        self.validator = StrategyValidator()
+        self.explainer = StrategyExplainer()
+        self.connector = MiniMaxConnector(api_key=api_key, model=model)
+
+    def parse_strategy(
+        self, user_message: str, conversation_history: list[dict] = None
+    ) -> dict:
+        strategy_config = self.connector.parse_strategy(
+            user_message, conversation_history
+        )
+
+        if "error" in strategy_config:
+            return strategy_config
+
+        is_valid, errors = self.validator.validate(strategy_config)
+        if not is_valid:
+            return {
+                "error": "Strategy validation failed",
+                "validation_errors": errors,
+                "partial_config": strategy_config,
+            }
+
+        return strategy_config
+
+    def explain_strategy(self, strategy_config: dict) -> str:
+        return self.explainer.explain(strategy_config)
+
+    def chat(self, user_message: str, conversation_history: list[dict] = None) -> dict:
+        strategy_config = self.parse_strategy(user_message, conversation_history)
+
+        if "error" in strategy_config:
+            explanation = f"I had trouble understanding your strategy: {strategy_config.get('error', 'Unknown error')}"
+            if "validation_errors" in strategy_config:
+                explanation += "\n\nValidation issues:"
+                for err in strategy_config["validation_errors"]:
+                    explanation += f"\n  - {err}"
+            return {
+                "response": explanation,
+                "strategy_config": strategy_config.get("partial_config"),
+                "success": False,
+            }
+
+        explanation = self.explain_strategy(strategy_config)
+        return {
+            "response": f"I've configured your strategy:\n\n{explanation}",
+            "strategy_config": strategy_config,
+            "success": True,
+        }
+
+
+def get_trading_crew(
+    api_key: Optional[str] = None, model: Optional[str] = None
+) -> TradingCrew:
+    if api_key is None:
+        settings = get_settings()
+        api_key = settings.MINIMAX_API_KEY
+    if model is None:
+        settings = get_settings()
+        model = settings.MINIMAX_MODEL
+
+    return TradingCrew(api_key=api_key, model=model)

src/backend/app/services/ai_agent/llm_connector.py

@@ -1,13 +1,108 @@
-from typing import Optional
+from typing import Optional, List, Dict, Any
+import httpx
+from crewai import LLM
 
 
-class LLMConnector:
+class MiniMaxLLM(LLM):
+    def __init__(self, api_key: str, model: str = "MiniMax-Text-01", **kwargs):
+        super().__init__(**kwargs)
+        self.api_key = api_key
+        self.model = model
+        self.base_url = "https://api.minimax.chat/v1"
+
+    def _call(self, messages: List[Dict[str, str]], **kwargs) -> str:
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "model": self.model,
+            "messages": messages,
+            "temperature": kwargs.get("temperature", 0.7),
+            "max_tokens": kwargs.get("max_tokens", 2048),
+        }
+        with httpx.Client(timeout=60.0) as client:
+            response = client.post(
+                f"{self.base_url}/chat/completions",
+                headers=headers,
+                json=payload,
+            )
+            response.raise_for_status()
+            return response.json()["choices"][0]["message"]["content"]
+
+    def call(self, messages: List[Dict[str, str]], **kwargs) -> str:
+        return self._call(messages, **kwargs)
+
+
+class MiniMaxConnector:
     def __init__(self, api_key: str, model: str = "MiniMax-Text-01"):
         self.api_key = api_key
         self.model = model
 
-    def chat(self, messages: list[dict], **kwargs):
-        raise NotImplementedError("LLM integration not yet implemented")
+    def chat(self, messages: list[dict], **kwargs) -> str:
+        formatted_messages = []
+        for msg in messages:
+            if isinstance(msg, dict):
+                formatted_messages.append(
+                    {
+                        "role": msg.get("role", "user"),
+                        "content": msg.get("content", str(msg)),
+                    }
+                )
+            else:
+                formatted_messages.append({"role": "user", "content": str(msg)})
 
-    def parse_strategy(self, user_message: str) -> dict:
-        raise NotImplementedError("Strategy parsing not yet implemented")
+        llm = MiniMaxLLM(api_key=self.api_key, model=self.model)
+        return llm.call(formatted_messages, **kwargs)
+
+    def parse_strategy(
+        self, user_message: str, conversation_history: list[dict] = None
+    ) -> dict:
+        system_prompt = """You are a trading strategy designer. Parse the user's natural language request into a JSON strategy_config object.
+
+Supported conditions (MVP):
+- price_drop: Token price drops by X% (requires: token, threshold_percent)
+- price_rise: Token price rises by X% (requires: token, threshold_percent)
+- volume_spike: Trading volume increases X% (requires: token, threshold_percent)
+- price_level: Price crosses above/below X (requires: token, price, direction)
+
+Output ONLY valid JSON with this schema:
+{
+    "conditions": [
+        {
+            "type": "price_drop|price_rise|volume_spike|price_level",
+            "params": {
+                "token": "TOKEN_SYMBOL",
+                "threshold_percent": number,  // for price_drop, price_rise, volume_spike
+                "price": number,              // for price_level
+                "direction": "above|below"    // for price_level
+            }
+        }
+    ],
+    "actions": [
+        {
+            "type": "buy|sell|notify",
+            "params": {}
+        }
+    ]
+}
+
+If the user wants a condition not in the supported list, ask for clarification.
+"""
+
+        messages = [{"role": "system", "content": system_prompt}]
+        if conversation_history:
+            for msg in conversation_history:
+                messages.append(
+                    {"role": msg.get("role", "user"), "content": msg.get("content", "")}
+                )
+        messages.append({"role": "user", "content": user_message})
+
+        response = self.chat(messages)
+        try:
+            import json
+
+            result = json.loads(response)
+            return result
+        except json.JSONDecodeError:
+            return {"error": "Failed to parse strategy", "raw_response": response}

src/backend/requirements.txt

@@ -10,3 +10,4 @@ crewai>=0.1.0
 anthropic>=0.18.0
 httpx>=0.26.0
 python-multipart>=0.0.6
+slowapi>=0.1.9