Upload 63 files

app/api/deps.py

@@ -0,0 +1,35 @@
+"""
+API dependencies.
+"""
+from typing import Generator, Optional
+
+from fastapi import Cookie, Header
+from sqlalchemy.orm import Session
+
+from app.core.database import get_db_for_session, get_default_session
+
+
+def get_session_id(
+    x_session_id: Optional[str] = Header(None),
+    numidium_session: Optional[str] = Cookie(None)
+) -> Optional[str]:
+    """Return the session id from header or cookie."""
+    return x_session_id or numidium_session
+
+
+def get_scoped_db(
+    x_session_id: Optional[str] = Header(None),
+    numidium_session: Optional[str] = Cookie(None)
+) -> Generator[Session, None, None]:
+    """
+    Provide a session-scoped DB if available, otherwise the default DB.
+    """
+    session_id = x_session_id or numidium_session
+    if session_id:
+        db = get_db_for_session(session_id)
+    else:
+        db = get_default_session()
+    try:
+        yield db
+    finally:
+        db.close()

app/api/routes/analyze.py

@@ -1,17 +1,17 @@
 """
 Analyze API Routes - LLM-based text analysis
 """
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel, Field
-from typing import Optional, List
-from sqlalchemy.orm import Session
-import traceback
-
-from app.core.database import get_db
-from app.services.nlp import entity_extractor
-from app.services.geocoding import geocode
-from app.models.entity import Entity, Relationship, Event
-from app.config import settings
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel, Field
+from typing import Optional, List
+from sqlalchemy.orm import Session
+import traceback
+
+from app.api.deps import get_scoped_db
+from app.services.nlp import entity_extractor
+from app.services.geocoding import geocode
+from app.models.entity import Entity, Relationship, Event
+from app.config import settings
 
 
 router = APIRouter(prefix="/analyze", tags=["Analysis"])
@@ -62,8 +62,8 @@ class AnalyzeResponse(BaseModel):
     stats: dict
 
 
-@router.post("", response_model=AnalyzeResponse)
-async def analyze_text(request: AnalyzeRequest):
+@router.post("", response_model=AnalyzeResponse)
+async def analyze_text(request: AnalyzeRequest, db: Session = Depends(get_scoped_db)):
     """
     Analyze text using LLM to extract entities, relationships, and events.
     
@@ -89,9 +89,7 @@ async def analyze_text(request: AnalyzeRequest):
         created_relationships = 0
         created_events = 0
         
-        db = next(get_db())
-        
-        # Helper function to parse date strings
+        # Helper function to parse date strings
         def parse_date(date_str):
             if not date_str:
                 return None

app/api/routes/chat.py

@@ -1,58 +1,63 @@
-"""
-Chat API Routes - Intelligent chat with RAG
-"""
-from fastapi import APIRouter, Depends, HTTPException
-from pydantic import BaseModel, Field
-from typing import Optional
-from sqlalchemy.orm import Session
-
-from app.core.database import get_db
-from app.services.chat import chat_service
-
-
-router = APIRouter(prefix="/chat", tags=["Chat"])
-
-
-class ChatRequest(BaseModel):
-    """Chat request model"""
-    message: str = Field(..., min_length=1, description="User message")
-    use_web: bool = Field(default=True, description="Include web search")
-    use_history: bool = Field(default=True, description="Use conversation history")
-
-
-class ChatResponse(BaseModel):
-    """Chat response model"""
-    answer: str
-    local_context_used: bool
-    web_context_used: bool
-    entities_found: int
-
-
-@router.post("", response_model=ChatResponse)
-async def chat(request: ChatRequest, db: Session = Depends(get_db)):
-    """
-    Send a message and get an intelligent response.
-    
-    Uses:
-    - Local NUMIDIUM knowledge (entities/relationships)
-    - Lancer web search (if enabled)
-    - Cerebras LLM for synthesis
-    """
-    try:
-        result = await chat_service.chat(
-            message=request.message,
-            db=db,
-            use_web=request.use_web,
-            use_history=request.use_history
-        )
-        return ChatResponse(**result)
-        
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@router.post("/clear")
-async def clear_history():
-    """Clear conversation history"""
-    chat_service.clear_history()
-    return {"message": "Histórico limpo"}
+"""
+Chat API Routes - Intelligent chat with RAG
+"""
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel, Field
+from typing import Optional
+from sqlalchemy.orm import Session
+
+from app.api.deps import get_scoped_db, get_session_id
+from app.services.chat import chat_service
+
+
+router = APIRouter(prefix="/chat", tags=["Chat"])
+
+
+class ChatRequest(BaseModel):
+    """Chat request model"""
+    message: str = Field(..., min_length=1, description="User message")
+    use_web: bool = Field(default=True, description="Include web search")
+    use_history: bool = Field(default=True, description="Use conversation history")
+
+
+class ChatResponse(BaseModel):
+    """Chat response model"""
+    answer: str
+    local_context_used: bool
+    web_context_used: bool
+    entities_found: int
+
+
+@router.post("", response_model=ChatResponse)
+async def chat(
+    request: ChatRequest,
+    db: Session = Depends(get_scoped_db),
+    session_id: Optional[str] = Depends(get_session_id)
+):
+    """
+    Send a message and get an intelligent response.
+
+    Uses:
+    - Local NUMIDIUM knowledge (entities/relationships)
+    - Lancer web search (if enabled)
+    - Cerebras LLM for synthesis
+    """
+    try:
+        result = await chat_service.chat(
+            message=request.message,
+            db=db,
+            use_web=request.use_web,
+            use_history=request.use_history,
+            session_id=session_id
+        )
+        return ChatResponse(**result)
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/clear")
+async def clear_history(session_id: Optional[str] = Depends(get_session_id)):
+    """Clear conversation history"""
+    chat_service.clear_history(session_id=session_id)
+    return {"message": "Historico limpo"}

app/api/routes/entities.py

@@ -1,77 +1,57 @@
-"""
-Entity CRUD Routes
-"""
-from fastapi import APIRouter, Depends, HTTPException, Query, Header, Cookie
-from sqlalchemy.orm import Session
-from sqlalchemy import or_
-from typing import List, Optional
-
-from app.core.database import get_db, get_db_for_session
-from app.models import Entity, Relationship
-from app.schemas import EntityCreate, EntityUpdate, EntityResponse, GraphData, GraphNode, GraphEdge
-
-router = APIRouter(prefix="/entities", tags=["Entities"])
-
-
-def get_session_or_default(
-    x_session_id: Optional[str] = Header(None),
-    numidium_session: Optional[str] = Cookie(None)
-) -> Optional[str]:
-    """Get session ID from header or cookie"""
-    return x_session_id or numidium_session
-
-
-@router.get("", response_model=List[EntityResponse])
-def list_entities(
-    type: Optional[str] = None,
-    search: Optional[str] = None,
-    project_id: Optional[str] = None,
-    limit: int = Query(default=50, le=200),
-    offset: int = 0,
-    x_session_id: Optional[str] = Header(None),
-    numidium_session: Optional[str] = Cookie(None)
-):
-    """Lista todas as entidades com filtros opcionais"""
-    session_id = x_session_id or numidium_session
-    
-    # Use session-specific database if session exists
-    if session_id:
-        db = get_db_for_session(session_id)
-    else:
-        db = next(get_db())
-    
-    try:
-        query = db.query(Entity)
-        
-        if project_id:
-            query = query.filter(Entity.project_id == project_id)
-        
-        if type:
-            query = query.filter(Entity.type == type)
-        
-        if search:
-            query = query.filter(
-                or_(
-                    Entity.name.ilike(f"%{search}%"),
-                    Entity.description.ilike(f"%{search}%")
-                )
-            )
-        
-        query = query.order_by(Entity.created_at.desc())
-        return query.offset(offset).limit(limit).all()
-    finally:
-        db.close()
+"""
+Entity CRUD Routes
+"""
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.orm import Session
+from sqlalchemy import or_
+from typing import List, Optional
+
+from app.api.deps import get_scoped_db
+from app.models import Entity, Relationship
+from app.schemas import EntityCreate, EntityUpdate, EntityResponse, GraphData, GraphNode, GraphEdge
+
+router = APIRouter(prefix="/entities", tags=["Entities"])
+
+
+@router.get("", response_model=List[EntityResponse])
+def list_entities(
+    type: Optional[str] = None,
+    search: Optional[str] = None,
+    project_id: Optional[str] = None,
+    limit: int = Query(default=50, le=200),
+    offset: int = 0,
+    db: Session = Depends(get_scoped_db)
+):
+    """Lista todas as entidades com filtros opcionais"""
+    query = db.query(Entity)
+    
+    if project_id:
+        query = query.filter(Entity.project_id == project_id)
+    
+    if type:
+        query = query.filter(Entity.type == type)
+    
+    if search:
+        query = query.filter(
+            or_(
+                Entity.name.ilike(f"%{search}%"),
+                Entity.description.ilike(f"%{search}%")
+            )
+        )
+    
+    query = query.order_by(Entity.created_at.desc())
+    return query.offset(offset).limit(limit).all()
 
 
-@router.get("/types")
-def get_entity_types(db: Session = Depends(get_db)):
+@router.get("/types")
+def get_entity_types(db: Session = Depends(get_scoped_db)):
     """Retorna todos os tipos de entidade únicos"""
     types = db.query(Entity.type).distinct().all()
     return [t[0] for t in types]
 
 
-@router.get("/{entity_id}", response_model=EntityResponse)
-def get_entity(entity_id: str, db: Session = Depends(get_db)):
+@router.get("/{entity_id}", response_model=EntityResponse)
+def get_entity(entity_id: str, db: Session = Depends(get_scoped_db)):
     """Busca uma entidade por ID"""
     entity = db.query(Entity).filter(Entity.id == entity_id).first()
     if not entity:
@@ -79,8 +59,8 @@ def get_entity(entity_id: str, db: Session = Depends(get_db)):
     return entity
 
 
-@router.post("", response_model=EntityResponse, status_code=201)
-def create_entity(entity: EntityCreate, db: Session = Depends(get_db)):
+@router.post("", response_model=EntityResponse, status_code=201)
+def create_entity(entity: EntityCreate, db: Session = Depends(get_scoped_db)):
     """Cria uma nova entidade"""
     db_entity = Entity(**entity.model_dump())
     db.add(db_entity)
@@ -89,8 +69,8 @@ def create_entity(entity: EntityCreate, db: Session = Depends(get_db)):
     return db_entity
 
 
-@router.put("/{entity_id}", response_model=EntityResponse)
-def update_entity(entity_id: str, entity: EntityUpdate, db: Session = Depends(get_db)):
+@router.put("/{entity_id}", response_model=EntityResponse)
+def update_entity(entity_id: str, entity: EntityUpdate, db: Session = Depends(get_scoped_db)):
     """Atualiza uma entidade existente"""
     db_entity = db.query(Entity).filter(Entity.id == entity_id).first()
     if not db_entity:
@@ -105,8 +85,8 @@ def update_entity(entity_id: str, entity: EntityUpdate, db: Session = Depends(ge
     return db_entity
 
 
-@router.delete("/{entity_id}")
-def delete_entity(entity_id: str, db: Session = Depends(get_db)):
+@router.delete("/{entity_id}")
+def delete_entity(entity_id: str, db: Session = Depends(get_scoped_db)):
     """Deleta uma entidade"""
     db_entity = db.query(Entity).filter(Entity.id == entity_id).first()
     if not db_entity:
@@ -125,12 +105,12 @@ def delete_entity(entity_id: str, db: Session = Depends(get_db)):
     return {"message": "Entity deleted"}
 
 
-@router.get("/{entity_id}/connections", response_model=GraphData)
-def get_entity_connections(
-    entity_id: str,
-    depth: int = Query(default=1, le=3),
-    db: Session = Depends(get_db)
-):
+@router.get("/{entity_id}/connections", response_model=GraphData)
+def get_entity_connections(
+    entity_id: str,
+    depth: int = Query(default=1, le=3),
+    db: Session = Depends(get_scoped_db)
+):
     """
     Retorna o grafo de conexões de uma entidade
     Usado para visualização de rede no frontend
@@ -187,12 +167,12 @@ def get_entity_connections(
     )
 
 
-@router.post("/merge")
-def merge_entities(
-    primary_id: str,
-    secondary_id: str,
-    db: Session = Depends(get_db)
-):
+@router.post("/merge")
+def merge_entities(
+    primary_id: str,
+    secondary_id: str,
+    db: Session = Depends(get_scoped_db)
+):
     """
     Merge two entities into one.
     The primary entity is kept, the secondary is deleted.
@@ -267,11 +247,11 @@ def merge_entities(
     }
 
 
-@router.get("/suggest-merge")
-async def suggest_merge_candidates(
-    limit: int = Query(default=10, le=50),
-    db: Session = Depends(get_db)
-):
+@router.get("/suggest-merge")
+async def suggest_merge_candidates(
+    limit: int = Query(default=10, le=50),
+    db: Session = Depends(get_scoped_db)
+):
     """
     Use LLM to find potential duplicate entities that could be merged.
     Returns pairs of entities that might be the same.

app/api/routes/events.py

@@ -1,116 +1,113 @@
-"""
-Events CRUD Routes
-"""
-from fastapi import APIRouter, Depends, HTTPException, Query
-from sqlalchemy.orm import Session
-from sqlalchemy import or_
-from typing import List, Optional
-from datetime import datetime
-
-from app.core.database import get_db
-from app.models import Event
-from app.schemas import EventCreate, EventResponse
-
-router = APIRouter(prefix="/events", tags=["Events"])
-
-
-@router.get("/", response_model=List[EventResponse])
-def list_events(
-    type: Optional[str] = None,
-    search: Optional[str] = None,
-    start_date: Optional[datetime] = None,
-    end_date: Optional[datetime] = None,
-    limit: int = Query(default=50, le=200),
-    offset: int = 0,
-    db: Session = Depends(get_db)
-):
-    """Lista eventos com filtros opcionais"""
-    query = db.query(Event)
-    
-    if type:
-        query = query.filter(Event.type == type)
-    
-    if search:
-        query = query.filter(
-            or_(
-                Event.title.ilike(f"%{search}%"),
-                Event.description.ilike(f"%{search}%")
-            )
-        )
-    
-    if start_date:
-        query = query.filter(Event.event_date >= start_date)
-    if end_date:
-        query = query.filter(Event.event_date <= end_date)
-    
-    query = query.order_by(Event.event_date.desc().nullslast())
-    return query.offset(offset).limit(limit).all()
-
-
-@router.get("/types")
-def get_event_types(db: Session = Depends(get_db)):
-    """Retorna todos os tipos de evento únicos"""
-    types = db.query(Event.type).distinct().all()
-    return [t[0] for t in types]
-
-
-@router.get("/timeline")
-def get_timeline(
-    entity_id: Optional[str] = None,
-    limit: int = Query(default=50, le=200),
-    db: Session = Depends(get_db)
-):
-    """
-    Retorna eventos em formato timeline
-    Útil para visualização no frontend
-    """
-    query = db.query(Event).filter(Event.event_date.isnot(None))
-    
-    if entity_id:
-        # Filter events that include this entity
-        # Note: This is a simple implementation; for production, use a proper JSON query
-        query = query.filter(Event.entity_ids.contains([entity_id]))
-    
-    events = query.order_by(Event.event_date.asc()).limit(limit).all()
-    
-    return [
-        {
-            "id": e.id,
-            "title": e.title,
-            "date": e.event_date.isoformat() if e.event_date else None,
-            "type": e.type,
-            "location": e.location_name
-        }
-        for e in events
-    ]
-
-
-@router.get("/{event_id}", response_model=EventResponse)
-def get_event(event_id: str, db: Session = Depends(get_db)):
-    """Busca um evento por ID"""
-    event = db.query(Event).filter(Event.id == event_id).first()
-    if not event:
-        raise HTTPException(status_code=404, detail="Event not found")
-    return event
-
-
-@router.post("/", response_model=EventResponse, status_code=201)
-def create_event(event: EventCreate, db: Session = Depends(get_db)):
-    """Cria um novo evento"""
-    db_event = Event(**event.model_dump())
-    db.add(db_event)
-    db.commit()
-    db.refresh(db_event)
-    return db_event
-
-
-@router.delete("/{event_id}")
-def delete_event(event_id: str, db: Session = Depends(get_db)):
-    """Deleta um evento"""
-    db_event = db.query(Event).filter(Event.id == event_id).first()
-    if not db_event:
-        raise HTTPException(status_code=404, detail="Event not found")
-    
-    db.delete(db_event)
-    db.commit()
-    return {"message": "Event deleted"}
+"""
+Events CRUD Routes
+"""
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.orm import Session
+from sqlalchemy import or_
+from typing import List, Optional
+from datetime import datetime
+
+from app.api.deps import get_scoped_db
+from app.models import Event
+from app.schemas import EventCreate, EventResponse
+
+router = APIRouter(prefix="/events", tags=["Events"])
+
+
+@router.get("/", response_model=List[EventResponse])
+def list_events(
+    type: Optional[str] = None,
+    search: Optional[str] = None,
+    start_date: Optional[datetime] = None,
+    end_date: Optional[datetime] = None,
+    limit: int = Query(default=50, le=200),
+    offset: int = 0,
+    db: Session = Depends(get_scoped_db)
+):
+    """Lista eventos com filtros opcionais"""
+    query = db.query(Event)
+
+    if type:
+        query = query.filter(Event.type == type)
+
+    if search:
+        query = query.filter(
+            or_(
+                Event.title.ilike(f"%{search}%"),
+                Event.description.ilike(f"%{search}%")
+            )
+        )
+
+    if start_date:
+        query = query.filter(Event.event_date >= start_date)
+    if end_date:
+        query = query.filter(Event.event_date <= end_date)
+
+    query = query.order_by(Event.event_date.desc().nullslast())
+    return query.offset(offset).limit(limit).all()
+
+
+@router.get("/types")
+def get_event_types(db: Session = Depends(get_scoped_db)):
+    """Retorna todos os tipos de evento unicos"""
+    types = db.query(Event.type).distinct().all()
+    return [t[0] for t in types]
+
+
+@router.get("/timeline")
+def get_timeline(
+    entity_id: Optional[str] = None,
+    limit: int = Query(default=50, le=200),
+    db: Session = Depends(get_scoped_db)
+):
+    """
+    Retorna eventos em formato timeline.
+    """
+    query = db.query(Event).filter(Event.event_date.isnot(None))
+
+    if entity_id:
+        query = query.filter(Event.entity_ids.contains([entity_id]))
+
+    events = query.order_by(Event.event_date.asc()).limit(limit).all()
+
+    return [
+        {
+            "id": e.id,
+            "title": e.title,
+            "date": e.event_date.isoformat() if e.event_date else None,
+            "type": e.type,
+            "location": e.location_name
+        }
+        for e in events
+    ]
+
+
+@router.get("/{event_id}", response_model=EventResponse)
+def get_event(event_id: str, db: Session = Depends(get_scoped_db)):
+    """Busca um evento por ID"""
+    event = db.query(Event).filter(Event.id == event_id).first()
+    if not event:
+        raise HTTPException(status_code=404, detail="Event not found")
+    return event
+
+
+@router.post("/", response_model=EventResponse, status_code=201)
+def create_event(event: EventCreate, db: Session = Depends(get_scoped_db)):
+    """Cria um novo evento"""
+    db_event = Event(**event.model_dump())
+    db.add(db_event)
+    db.commit()
+    db.refresh(db_event)
+    return db_event
+
+
+@router.delete("/{event_id}")
+def delete_event(event_id: str, db: Session = Depends(get_scoped_db)):
+    """Deleta um evento"""
+    db_event = db.query(Event).filter(Event.id == event_id).first()
+    if not db_event:
+        raise HTTPException(status_code=404, detail="Event not found")
+
+    db.delete(db_event)
+    db.commit()
+    return {"message": "Event deleted"}

app/api/routes/graph.py

@@ -1,29 +1,29 @@
 """
 Graph API Routes - Network visualization endpoints
 """
-from fastapi import APIRouter, HTTPException, Query
-from typing import Optional, List
-from sqlalchemy import or_
-
-from app.core.database import get_db
-from app.models.entity import Entity, Relationship
-
-
-router = APIRouter(prefix="/graph", tags=["Graph"])
+from fastapi import APIRouter, Depends, HTTPException, Query
+from typing import Optional, List
+from sqlalchemy.orm import Session
+from sqlalchemy import or_
+
+from app.api.deps import get_scoped_db
+from app.models.entity import Entity, Relationship
+
+
+router = APIRouter(prefix="/graph", tags=["Graph"])
 
 
 @router.get("")
-async def get_graph(
-    entity_type: Optional[str] = Query(None, description="Filter by entity type"),
-    limit: int = Query(100, le=500, description="Maximum number of entities")
-):
+async def get_graph(
+    entity_type: Optional[str] = Query(None, description="Filter by entity type"),
+    limit: int = Query(100, le=500, description="Maximum number of entities"),
+    db: Session = Depends(get_scoped_db)
+):
     """
     Get graph data for visualization.
     Returns nodes (entities) and edges (relationships).
     """
-    try:
-        db = next(get_db())
-        
+    try:
         # Get entities
         query = db.query(Entity)
         if entity_type:
@@ -56,7 +56,6 @@ async def get_graph(
         
         edges = []
         for r in relationships:
-            # Only include edges where both nodes exist
             if r.source_id in entity_ids and r.target_id in entity_ids:
                 edges.append({
                     "data": {
@@ -82,16 +81,15 @@ async def get_graph(
 
 
 @router.get("/entity/{entity_id}")
-async def get_entity_graph(
-    entity_id: str,
-    depth: int = Query(1, ge=1, le=3, description="How many levels of connections to include")
-):
+async def get_entity_graph(
+    entity_id: str,
+    depth: int = Query(1, ge=1, le=3, description="How many levels of connections to include"),
+    db: Session = Depends(get_scoped_db)
+):
     """
     Get graph centered on a specific entity.
     """
-    try:
-        db = next(get_db())
-        
+    try:
         # Get the central entity
         central = db.query(Entity).filter(Entity.id == entity_id).first()
         if not central:
@@ -102,7 +100,6 @@ async def get_entity_graph(
         current_level = {entity_id}
         
         for _ in range(depth):
-            # Get relationships for current level entities
             rels = db.query(Relationship).filter(
                 or_(
                     Relationship.source_id.in_(current_level),
@@ -110,13 +107,11 @@ async def get_entity_graph(
                 )
             ).all()
             
-            # Collect new entity IDs
             next_level = set()
             for r in rels:
                 next_level.add(r.source_id)
                 next_level.add(r.target_id)
             
-            # Update for next iteration
             current_level = next_level - collected_ids
             collected_ids.update(next_level)
         
@@ -175,3 +170,4 @@ async def get_entity_graph(
         raise
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Failed to get entity graph: {str(e)}")
+

app/api/routes/ingest.py

@@ -2,15 +2,15 @@
 Data Ingestion Routes
 Endpoints para importar dados de fontes externas
 """
-from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
-from sqlalchemy.orm import Session
-from typing import Optional, List
-from datetime import datetime
-import asyncio
-
-from app.core.database import get_db
-from app.models import Entity, Document, Relationship
-from app.schemas import EntityResponse, DocumentResponse
+from fastapi import APIRouter, Depends, HTTPException, BackgroundTasks
+from sqlalchemy.orm import Session
+from typing import Optional, List
+from datetime import datetime
+import asyncio
+
+from app.api.deps import get_scoped_db
+from app.models import Entity, Document, Relationship
+from app.schemas import EntityResponse, DocumentResponse
 from app.services.ingestion import wikipedia_scraper, news_service
 from app.services.nlp import entity_extractor
 from app.services.geocoding import geocode
@@ -43,20 +43,20 @@ def search_wikipedia(q: str, limit: int = 10):
 
 
 @router.post("/wikipedia/entity", response_model=EntityResponse)
-async def import_from_wikipedia(
-    title: str,
-    entity_type: str = "person",
-    project_id: Optional[str] = None,
-    auto_extract: bool = True,
-    db: Session = Depends(get_db)
-):
+async def import_from_wikipedia(
+    title: str,
+    entity_type: str = "person",
+    project_id: Optional[str] = None,
+    auto_extract: bool = True,
+    db: Session = Depends(get_scoped_db)
+):
     """
     Importa uma entidade da Wikipedia
     entity_type: person, organization, location
     project_id: ID do projeto para associar a entidade
     auto_extract: Se True, usa LLM para extrair entidades relacionadas
     """
-    # Check if entity already exists
+    # Check if entity already exists
     existing = db.query(Entity).filter(
         Entity.name == title,
         Entity.source == "wikipedia"
@@ -201,12 +201,12 @@ def search_news(q: str):
 
 
 @router.post("/news/import")
-async def import_news(
-    query: Optional[str] = None,
-    feed: Optional[str] = None,
-    auto_extract: bool = True,
-    db: Session = Depends(get_db)
-):
+async def import_news(
+    query: Optional[str] = None,
+    feed: Optional[str] = None,
+    auto_extract: bool = True,
+    db: Session = Depends(get_scoped_db)
+):
     """
     Importa notícias como documentos no sistema
     auto_extract: Se True, usa LLM para extrair entidades de cada notícia
@@ -314,10 +314,10 @@ async def import_news(
 # ========== Manual Import ==========
 
 @router.post("/bulk/entities")
-def bulk_import_entities(
-    entities: List[dict],
-    db: Session = Depends(get_db)
-):
+def bulk_import_entities(
+    entities: List[dict],
+    db: Session = Depends(get_scoped_db)
+):
     """
     Importa múltiplas entidades de uma vez
     Útil para importar de CSV/JSON

app/api/routes/projects.py

@@ -1,13 +1,14 @@
 """
 Projects API Routes - Workspace management
 """
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel
-from typing import Optional, List
-from datetime import datetime
-
-from app.core.database import get_db
-from app.models import Project, Entity, Relationship
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel
+from typing import Optional, List
+from datetime import datetime
+from sqlalchemy.orm import Session
+
+from app.api.deps import get_scoped_db
+from app.models import Project, Entity, Relationship
 
 
 router = APIRouter(prefix="/projects", tags=["Projects"])
@@ -33,11 +34,10 @@ class ProjectResponse(BaseModel):
         from_attributes = True
 
 
-@router.get("", response_model=List[ProjectResponse])
-def list_projects():
-    """List all projects"""
-    db = next(get_db())
-    projects = db.query(Project).order_by(Project.created_at.desc()).all()
+@router.get("", response_model=List[ProjectResponse])
+def list_projects(db: Session = Depends(get_scoped_db)):
+    """List all projects"""
+    projects = db.query(Project).order_by(Project.created_at.desc()).all()
     
     result = []
     for p in projects:
@@ -55,14 +55,12 @@ def list_projects():
     return result
 
 
-@router.post("", response_model=ProjectResponse)
-def create_project(project: ProjectCreate):
-    """Create a new project"""
-    db = next(get_db())
-    
-    new_project = Project(
-        name=project.name,
-        description=project.description,
+@router.post("", response_model=ProjectResponse)
+def create_project(project: ProjectCreate, db: Session = Depends(get_scoped_db)):
+    """Create a new project"""
+    new_project = Project(
+        name=project.name,
+        description=project.description,
         color=project.color,
         icon=project.icon
     )
@@ -81,11 +79,10 @@ def create_project(project: ProjectCreate):
     )
 
 
-@router.get("/{project_id}", response_model=ProjectResponse)
-def get_project(project_id: str):
-    """Get project by ID"""
-    db = next(get_db())
-    project = db.query(Project).filter(Project.id == project_id).first()
+@router.get("/{project_id}", response_model=ProjectResponse)
+def get_project(project_id: str, db: Session = Depends(get_scoped_db)):
+    """Get project by ID"""
+    project = db.query(Project).filter(Project.id == project_id).first()
     
     if not project:
         raise HTTPException(status_code=404, detail="Project not found")
@@ -103,11 +100,10 @@ def get_project(project_id: str):
     )
 
 
-@router.delete("/{project_id}")
-def delete_project(project_id: str):
-    """Delete project and optionally its entities"""
-    db = next(get_db())
-    project = db.query(Project).filter(Project.id == project_id).first()
+@router.delete("/{project_id}")
+def delete_project(project_id: str, db: Session = Depends(get_scoped_db)):
+    """Delete project and optionally its entities"""
+    project = db.query(Project).filter(Project.id == project_id).first()
     
     if not project:
         raise HTTPException(status_code=404, detail="Project not found")
@@ -122,11 +118,10 @@ def delete_project(project_id: str):
     return {"message": f"Project '{project.name}' deleted"}
 
 
-@router.put("/{project_id}")
-def update_project(project_id: str, project: ProjectCreate):
-    """Update project"""
-    db = next(get_db())
-    existing = db.query(Project).filter(Project.id == project_id).first()
+@router.put("/{project_id}")
+def update_project(project_id: str, project: ProjectCreate, db: Session = Depends(get_scoped_db)):
+    """Update project"""
+    existing = db.query(Project).filter(Project.id == project_id).first()
     
     if not existing:
         raise HTTPException(status_code=404, detail="Project not found")

app/api/routes/relationships.py

@@ -1,71 +1,76 @@
-"""
-Relationship CRUD Routes
-"""
-from fastapi import APIRouter, Depends, HTTPException, Query
-from sqlalchemy.orm import Session
-from typing import List, Optional
-
-from app.core.database import get_db
-from app.models import Relationship, Entity
-from app.schemas import RelationshipCreate, RelationshipResponse
-
-router = APIRouter(prefix="/relationships", tags=["Relationships"])
-
-
-@router.get("/", response_model=List[RelationshipResponse])
-def list_relationships(
-    type: Optional[str] = None,
-    source_id: Optional[str] = None,
-    target_id: Optional[str] = None,
-    limit: int = Query(default=50, le=200),
-    db: Session = Depends(get_db)
-):
-    """Lista relacionamentos com filtros opcionais"""
-    query = db.query(Relationship)
-    
-    if type:
-        query = query.filter(Relationship.type == type)
-    if source_id:
-        query = query.filter(Relationship.source_id == source_id)
-    if target_id:
-        query = query.filter(Relationship.target_id == target_id)
-    
-    return query.limit(limit).all()
-
-
-@router.get("/types")
-def get_relationship_types(db: Session = Depends(get_db)):
-    """Retorna todos os tipos de relacionamento únicos"""
-    types = db.query(Relationship.type).distinct().all()
-    return [t[0] for t in types]
-
-
-@router.post("/", response_model=RelationshipResponse, status_code=201)
-def create_relationship(rel: RelationshipCreate, db: Session = Depends(get_db)):
-    """Cria um novo relacionamento entre entidades"""
-    # Verify both entities exist
-    source = db.query(Entity).filter(Entity.id == rel.source_id).first()
-    target = db.query(Entity).filter(Entity.id == rel.target_id).first()
-    
-    if not source:
-        raise HTTPException(status_code=404, detail="Source entity not found")
-    if not target:
-        raise HTTPException(status_code=404, detail="Target entity not found")
-    
-    db_rel = Relationship(**rel.model_dump())
-    db.add(db_rel)
-    db.commit()
-    db.refresh(db_rel)
-    return db_rel
-
-
-@router.delete("/{relationship_id}")
-def delete_relationship(relationship_id: str, db: Session = Depends(get_db)):
-    """Deleta um relacionamento"""
-    db_rel = db.query(Relationship).filter(Relationship.id == relationship_id).first()
-    if not db_rel:
-        raise HTTPException(status_code=404, detail="Relationship not found")
-    
-    db.delete(db_rel)
-    db.commit()
-    return {"message": "Relationship deleted"}
+"""
+Relationship CRUD Routes
+"""
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.orm import Session
+from typing import List, Optional
+
+from app.api.deps import get_scoped_db
+from app.models import Relationship, Entity
+from app.schemas import RelationshipCreate, RelationshipResponse
+
+router = APIRouter(prefix="/relationships", tags=["Relationships"])
+
+
+@router.get("/", response_model=List[RelationshipResponse])
+def list_relationships(
+    type: Optional[str] = None,
+    source_id: Optional[str] = None,
+    target_id: Optional[str] = None,
+    limit: int = Query(default=50, le=200),
+    db: Session = Depends(get_scoped_db)
+):
+    """Lista relacionamentos com filtros opcionais"""
+    query = db.query(Relationship)
+
+    if type:
+        query = query.filter(Relationship.type == type)
+    if source_id:
+        query = query.filter(Relationship.source_id == source_id)
+    if target_id:
+        query = query.filter(Relationship.target_id == target_id)
+
+    return query.limit(limit).all()
+
+
+@router.get("/types")
+def get_relationship_types(db: Session = Depends(get_scoped_db)):
+    """Retorna todos os tipos de relacionamento unicos"""
+    types = db.query(Relationship.type).distinct().all()
+    return [t[0] for t in types]
+
+
+@router.post("/", response_model=RelationshipResponse, status_code=201)
+def create_relationship(
+    rel: RelationshipCreate,
+    db: Session = Depends(get_scoped_db)
+):
+    """Cria um novo relacionamento entre entidades"""
+    source = db.query(Entity).filter(Entity.id == rel.source_id).first()
+    target = db.query(Entity).filter(Entity.id == rel.target_id).first()
+
+    if not source:
+        raise HTTPException(status_code=404, detail="Source entity not found")
+    if not target:
+        raise HTTPException(status_code=404, detail="Target entity not found")
+
+    db_rel = Relationship(**rel.model_dump())
+    db.add(db_rel)
+    db.commit()
+    db.refresh(db_rel)
+    return db_rel
+
+
+@router.delete("/{relationship_id}")
+def delete_relationship(
+    relationship_id: str,
+    db: Session = Depends(get_scoped_db)
+):
+    """Deleta um relacionamento"""
+    db_rel = db.query(Relationship).filter(Relationship.id == relationship_id).first()
+    if not db_rel:
+        raise HTTPException(status_code=404, detail="Relationship not found")
+
+    db.delete(db_rel)
+    db.commit()
+    return {"message": "Relationship deleted"}

app/api/routes/research.py

@@ -1,16 +1,17 @@
 """
 Research API Routes - Deep research with automatic entity extraction
 """
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel, Field
-from typing import Optional, List
-import traceback
-
-from app.core.database import get_db
-from app.services import lancer
-from app.services.nlp import entity_extractor
-from app.services.geocoding import geocode
-from app.models.entity import Entity, Relationship
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel, Field
+from typing import Optional, List
+import traceback
+from sqlalchemy.orm import Session
+
+from app.api.deps import get_scoped_db
+from app.services import lancer
+from app.services.nlp import entity_extractor
+from app.services.geocoding import geocode
+from app.models.entity import Entity, Relationship
 
 
 router = APIRouter(prefix="/research", tags=["Research"])
@@ -35,8 +36,8 @@ class ResearchResponse(BaseModel):
     processing_time_ms: float
 
 
-@router.post("", response_model=ResearchResponse)
-async def research(request: ResearchRequest):
+@router.post("", response_model=ResearchResponse)
+async def research(request: ResearchRequest, db: Session = Depends(get_scoped_db)):
     """
     Perform AI-powered research using Lancer API and optionally extract entities.
     
@@ -60,9 +61,7 @@ async def research(request: ResearchRequest):
         # Extract entities if enabled
         if request.auto_extract and result.raw_text:
             try:
-                db = next(get_db())
-                
-                # Limit text to avoid token limits
+                # Limit text to avoid token limits
                 text_to_analyze = result.raw_text[:5000]
                 ner_result = await entity_extractor.extract(text_to_analyze)
                 

app/api/routes/search.py

@@ -1,133 +1,126 @@
-"""
-Search and Analytics Routes
-"""
-from fastapi import APIRouter, Depends, Query
-from sqlalchemy.orm import Session
-from sqlalchemy import or_, func
-from typing import Optional, List
-
-from app.core.database import get_db
-from app.models import Entity, Relationship, Event, Document
-from app.schemas import SearchResult, SystemStats, EntityResponse, EventResponse, DocumentResponse
-
-router = APIRouter(prefix="/search", tags=["Search"])
-
-
-@router.get("", response_model=SearchResult)
-def global_search(
-    q: str = Query(..., min_length=2, description="Search query"),
-    types: Optional[str] = Query(None, description="Entity types (comma-separated)"),
-    limit: int = Query(default=20, le=100),
-    db: Session = Depends(get_db)
-):
-    """
-    Busca global em todas as entidades, eventos e documentos
-    """
-    search_term = f"%{q}%"
-    type_filter = types.split(",") if types else None
-    
-    # Search entities
-    entity_query = db.query(Entity).filter(
-        or_(
-            Entity.name.ilike(search_term),
-            Entity.description.ilike(search_term)
-        )
-    )
-    if type_filter:
-        entity_query = entity_query.filter(Entity.type.in_(type_filter))
-    entities = entity_query.limit(limit).all()
-    
-    # Search events
-    events = db.query(Event).filter(
-        or_(
-            Event.title.ilike(search_term),
-            Event.description.ilike(search_term)
-        )
-    ).limit(limit).all()
-    
-    # Search documents
-    documents = db.query(Document).filter(
-        or_(
-            Document.title.ilike(search_term),
-            Document.content.ilike(search_term)
-        )
-    ).limit(limit).all()
-    
-    return SearchResult(
-        entities=entities,
-        events=events,
-        documents=documents
-    )
-
-
-@router.get("/stats", response_model=SystemStats)
-def get_system_stats(db: Session = Depends(get_db)):
-    """
-    Retorna estatísticas gerais do sistema
-    Usado no dashboard do VANTAGE
-    """
-    total_entities = db.query(Entity).count()
-    total_relationships = db.query(Relationship).count()
-    total_events = db.query(Event).count()
-    total_documents = db.query(Document).count()
-    
-    # Count by entity type
-    type_counts = db.query(
-        Entity.type,
-        func.count(Entity.id)
-    ).group_by(Entity.type).all()
-    
-    entities_by_type = {t: c for t, c in type_counts}
-    
-    # Recent activity (last 10 entities created)
-    recent = db.query(Entity).order_by(Entity.created_at.desc()).limit(10).all()
-    recent_activity = [
-        {
-            "id": e.id,
-            "type": e.type,
-            "name": e.name,
-            "created_at": e.created_at.isoformat()
-        }
-        for e in recent
-    ]
-    
-    return SystemStats(
-        total_entities=total_entities,
-        total_relationships=total_relationships,
-        total_events=total_events,
-        total_documents=total_documents,
-        entities_by_type=entities_by_type,
-        recent_activity=recent_activity
-    )
-
-
-@router.get("/geo")
-def get_geo_data(
-    entity_type: Optional[str] = None,
-    db: Session = Depends(get_db)
-):
-    """
-    Retorna entidades com geolocalização
-    Usado para visualização em mapa
-    """
-    query = db.query(Entity).filter(
-        Entity.latitude.isnot(None),
-        Entity.longitude.isnot(None)
-    )
-    
-    if entity_type:
-        query = query.filter(Entity.type == entity_type)
-    
-    entities = query.all()
-    
-    return [
-        {
-            "id": e.id,
-            "type": e.type,
-            "name": e.name,
-            "lat": e.latitude,
-            "lng": e.longitude,
-            "properties": e.properties
-        }
-        for e in entities
-    ]
+"""
+Search and Analytics Routes
+"""
+from fastapi import APIRouter, Depends, Query
+from sqlalchemy.orm import Session
+from sqlalchemy import or_, func
+from typing import Optional
+
+from app.api.deps import get_scoped_db
+from app.models import Entity, Relationship, Event, Document
+from app.schemas import SearchResult, SystemStats
+
+router = APIRouter(prefix="/search", tags=["Search"])
+
+
+@router.get("", response_model=SearchResult)
+def global_search(
+    q: str = Query(..., min_length=2, description="Search query"),
+    types: Optional[str] = Query(None, description="Entity types (comma-separated)"),
+    limit: int = Query(default=20, le=100),
+    db: Session = Depends(get_scoped_db)
+):
+    """
+    Busca global em todas as entidades, eventos e documentos.
+    """
+    search_term = f"%{q}%"
+    type_filter = types.split(",") if types else None
+
+    entity_query = db.query(Entity).filter(
+        or_(
+            Entity.name.ilike(search_term),
+            Entity.description.ilike(search_term)
+        )
+    )
+    if type_filter:
+        entity_query = entity_query.filter(Entity.type.in_(type_filter))
+    entities = entity_query.limit(limit).all()
+
+    events = db.query(Event).filter(
+        or_(
+            Event.title.ilike(search_term),
+            Event.description.ilike(search_term)
+        )
+    ).limit(limit).all()
+
+    documents = db.query(Document).filter(
+        or_(
+            Document.title.ilike(search_term),
+            Document.content.ilike(search_term)
+        )
+    ).limit(limit).all()
+
+    return SearchResult(
+        entities=entities,
+        events=events,
+        documents=documents
+    )
+
+
+@router.get("/stats", response_model=SystemStats)
+def get_system_stats(db: Session = Depends(get_scoped_db)):
+    """
+    Retorna estatisticas gerais do sistema.
+    """
+    total_entities = db.query(Entity).count()
+    total_relationships = db.query(Relationship).count()
+    total_events = db.query(Event).count()
+    total_documents = db.query(Document).count()
+
+    type_counts = db.query(
+        Entity.type,
+        func.count(Entity.id)
+    ).group_by(Entity.type).all()
+
+    entities_by_type = {t: c for t, c in type_counts}
+
+    recent = db.query(Entity).order_by(Entity.created_at.desc()).limit(10).all()
+    recent_activity = [
+        {
+            "id": e.id,
+            "type": e.type,
+            "name": e.name,
+            "created_at": e.created_at.isoformat()
+        }
+        for e in recent
+    ]
+
+    return SystemStats(
+        total_entities=total_entities,
+        total_relationships=total_relationships,
+        total_events=total_events,
+        total_documents=total_documents,
+        entities_by_type=entities_by_type,
+        recent_activity=recent_activity
+    )
+
+
+@router.get("/geo")
+def get_geo_data(
+    entity_type: Optional[str] = None,
+    db: Session = Depends(get_scoped_db)
+):
+    """
+    Retorna entidades com geolocalizacao.
+    """
+    query = db.query(Entity).filter(
+        Entity.latitude.isnot(None),
+        Entity.longitude.isnot(None)
+    )
+
+    if entity_type:
+        query = query.filter(Entity.type == entity_type)
+
+    entities = query.all()
+
+    return [
+        {
+            "id": e.id,
+            "type": e.type,
+            "name": e.name,
+            "lat": e.latitude,
+            "lng": e.longitude,
+            "properties": e.properties
+        }
+        for e in entities
+    ]

app/api/routes/session.py

@@ -1,28 +1,35 @@
-"""
-Session management routes
-"""
-from fastapi import APIRouter, Header, Cookie, Response
-from typing import Optional
-import uuid
-
-from app.core.database import create_new_session_id
+"""
+Session management routes
+"""
+from fastapi import APIRouter, Header, Cookie, Response, Request
+from typing import Optional
+import uuid
+
+from app.core.database import create_new_session_id
+from app.config import settings
 
 router = APIRouter(prefix="/session", tags=["Session"])
-
-
-@router.post("/create")
-def create_session(response: Response):
-    """Create a new session and return session_id"""
-    session_id = create_new_session_id()
-    response.set_cookie(
-        key="numidium_session",
-        value=session_id,
-        max_age=60*60*24*365,  # 1 year
-        httponly=True,
-        samesite="none",
-        secure=True
-    )
-    return {"session_id": session_id}
+
+
+@router.post("/create")
+def create_session(response: Response, request: Request):
+    """Create a new session and return session_id"""
+    session_id = create_new_session_id()
+    secure = settings.cookie_secure
+    samesite = settings.cookie_samesite
+    proto = request.headers.get("x-forwarded-proto", request.url.scheme)
+    if proto != "https" and secure:
+        secure = False
+        samesite = "lax"
+    response.set_cookie(
+        key="numidium_session",
+        value=session_id,
+        max_age=60*60*24*365,  # 1 year
+        httponly=True,
+        samesite=samesite,
+        secure=secure
+    )
+    return {"session_id": session_id}
 
 
 @router.get("/current")

app/api/routes/timeline.py

@@ -1,14 +1,15 @@
 """
 Timeline API Routes - Temporal view of entities and relationships
 """
-from fastapi import APIRouter, Query
-from pydantic import BaseModel
-from typing import Optional, List, Dict, Any
-from datetime import datetime, timedelta
-from collections import defaultdict
-
-from app.core.database import get_db
-from app.models.entity import Entity, Relationship
+from fastapi import APIRouter, Depends, Query
+from pydantic import BaseModel
+from typing import Optional, List, Dict, Any
+from datetime import datetime, timedelta
+from collections import defaultdict
+from sqlalchemy.orm import Session
+
+from app.api.deps import get_scoped_db
+from app.models.entity import Entity, Relationship
 
 
 router = APIRouter(prefix="/timeline", tags=["Timeline"])
@@ -35,19 +36,18 @@ class TimelineResponse(BaseModel):
     total_events: int
 
 
-@router.get("", response_model=TimelineResponse)
-async def get_timeline(
-    days: int = Query(default=30, ge=1, le=365),
-    entity_type: Optional[str] = None,
-    limit: int = Query(default=100, ge=1, le=500)
-):
+@router.get("", response_model=TimelineResponse)
+async def get_timeline(
+    days: int = Query(default=30, ge=1, le=365),
+    entity_type: Optional[str] = None,
+    limit: int = Query(default=100, ge=1, le=500),
+    db: Session = Depends(get_scoped_db)
+):
     """
     Get timeline of recent entities and relationships.
     Groups events by date.
     """
-    db = next(get_db())
-    
-    # Calculate date range
+    # Calculate date range
     end_date = datetime.now()
     start_date = end_date - timedelta(days=days)
     
@@ -136,10 +136,9 @@ async def get_timeline(
     )
 
 
-@router.get("/stats")
-async def get_timeline_stats():
-    """Get statistics for timeline visualization"""
-    db = next(get_db())
+@router.get("/stats")
+async def get_timeline_stats(db: Session = Depends(get_scoped_db)):
+    """Get statistics for timeline visualization"""
     
     # Count entities by type
     entity_counts = {}

app/config.py

@@ -23,8 +23,12 @@ class Settings(BaseSettings):
     # Cerebras API for LLM-based entity extraction
     cerebras_api_key: str = ""
     
-    # CORS
-    cors_origins: list[str] = ["*"]
+    # CORS
+    cors_origins: list[str] = ["*"]
+
+    # Session cookie
+    cookie_secure: bool = True
+    cookie_samesite: str = "none"
     
     class Config:
         env_file = ".env"

app/core/database.py

@@ -62,16 +62,21 @@ engine = create_engine(
     settings.database_url,
     connect_args={"check_same_thread": False}
 )
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-
-
-def get_db():
-    """Legacy: Default database session"""
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+
+def get_default_session() -> Session:
+    """Create a new session for the default database."""
+    return SessionLocal()
+
+
+def get_db():
+    """Legacy: Default database session"""
+    db = get_default_session()
+    try:
+        yield db
+    finally:
+        db.close()
 
 
 def _run_migrations(eng):

app/services/chat.py

@@ -7,8 +7,7 @@ from typing import Optional, List, Dict, Any
 from sqlalchemy.orm import Session
 
 from app.config import settings
-from app.core.database import get_db
-from app.models.entity import Entity, Relationship
+from app.models.entity import Entity, Relationship
 
 
 LANCER_URL = "https://madras1-lancer.hf.space/api/v1"
@@ -24,13 +23,20 @@ Se não tiver certeza, diga que não sabe em vez de inventar."""
 class ChatService:
     """Chat service with RAG using local database and Lancer"""
     
-    def __init__(self):
-        self.api_url = "https://api.cerebras.ai/v1/chat/completions"
-        self.conversation_history: List[Dict[str, str]] = []
-    
-    def clear_history(self):
-        """Clear conversation history"""
-        self.conversation_history = []
+    def __init__(self):
+        self.api_url = "https://api.cerebras.ai/v1/chat/completions"
+        self.conversation_history: Dict[str, List[Dict[str, str]]] = {}
+    
+    def _get_history(self, session_id: Optional[str]) -> List[Dict[str, str]]:
+        key = session_id or "default"
+        if key not in self.conversation_history:
+            self.conversation_history[key] = []
+        return self.conversation_history[key]
+
+    def clear_history(self, session_id: Optional[str] = None):
+        """Clear conversation history"""
+        key = session_id or "default"
+        self.conversation_history.pop(key, None)
     
     def _get_local_context(self, query: str, db: Session, limit: int = 5) -> str:
         """Get relevant entities from local database"""
@@ -146,17 +152,19 @@ class ChatService:
         except Exception as e:
             return f"Erro: {str(e)}"
     
-    async def chat(
-        self, 
-        message: str, 
-        db: Session,
-        use_web: bool = True,
-        use_history: bool = True
-    ) -> Dict[str, Any]:
-        """Process chat message with RAG"""
-        
-        # Get local context
-        local_context = self._get_local_context(message, db)
+    async def chat(
+        self, 
+        message: str, 
+        db: Session,
+        use_web: bool = True,
+        use_history: bool = True,
+        session_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """Process chat message with RAG"""
+        history = self._get_history(session_id)
+        
+        # Get local context
+        local_context = self._get_local_context(message, db)
         
         # Get web context if enabled
         web_context = ""
@@ -172,11 +180,11 @@ class ChatService:
         
         context = "\n\n".join(context_parts) if context_parts else "Nenhum contexto disponível."
         
-        # Build messages
-        messages = [{"role": "system", "content": SYSTEM_PROMPT}]
-        
-        if use_history and self.conversation_history:
-            messages.extend(self.conversation_history[-6:])
+        # Build messages
+        messages = [{"role": "system", "content": SYSTEM_PROMPT}]
+        
+        if use_history and history:
+            messages.extend(history[-6:])
         
         user_message = f"""Contexto:
 {context}
@@ -185,12 +193,13 @@ Pergunta: {message}"""
         
         messages.append({"role": "user", "content": user_message})
         
-        # Call LLM
-        response = await self._call_llm(messages)
-        
-        # Store history
-        self.conversation_history.append({"role": "user", "content": message})
-        self.conversation_history.append({"role": "assistant", "content": response})
+        # Call LLM
+        response = await self._call_llm(messages)
+        
+        # Store history
+        if use_history:
+            history.append({"role": "user", "content": message})
+            history.append({"role": "assistant", "content": response})
         
         return {
             "answer": response,