Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /alkimya_gathering /gathering /api /dependencies.py
"""
FastAPI dependencies for dependency injection.
"""
import os
from typing import Dict, Optional, List, Any
from functools import lru_cache
from gathering.orchestration import GatheringCircle
from gathering.agents import MemoryService, AgentWrapper
# Import pycopg (local PostgreSQL wrapper)
from pycopg import Database as PycopgDatabase, Config as PycopgConfig
from gathering.utils.sql import safe_update_builder
# =============================================================================
# Database Connection
# =============================================================================
class DatabaseService:
"""Database service for API using pycopg."""
_instance: Optional['DatabaseService'] = None
@classmethod
def get_instance(cls) -> 'DatabaseService':
"""Get or create the singleton DatabaseService instance."""
if cls._instance is None:
cls._instance = cls()
return cls._instance
def __init__(self):
from dotenv import load_dotenv
load_dotenv()
# Support DATABASE_URL (used in CI) or individual DB_* vars
database_url = os.getenv('DATABASE_URL')
if database_url:
# Parse postgresql://user:password@host:port/database
from urllib.parse import urlparse
parsed = urlparse(database_url)
self._config = PycopgConfig(
host=parsed.hostname or 'localhost',
port=parsed.port or 5432,
database=parsed.path.lstrip('/') or 'gathering',
user=parsed.username or 'postgres',
password=parsed.password or '',
)
else:
self._config = PycopgConfig(
host=os.getenv('DB_HOST', 'localhost'),
port=int(os.getenv('DB_PORT', '5432')),
database=os.getenv('DB_NAME', 'gathering'),
user=os.getenv('DB_USER', 'loc'),
password=os.getenv('DB_PASSWORD', ''),
)
self._db = PycopgDatabase(self._config)
@property
def db(self) -> PycopgDatabase:
return self._db
def execute(self, sql: str, params: Optional[Dict] = None) -> List[Dict]:
"""Execute query and return list of dicts."""
result = self._db.execute(sql, params or {})
return list(result)
def execute_one(self, sql: str, params: Optional[Dict] = None) -> Optional[Dict]:
"""Execute query and return first row as dict."""
rows = self.execute(sql, params)
return rows[0] if rows else None
def fetch_all(self, sql: str, params: Optional[Dict] = None) -> List[Dict]:
"""Fetch all rows as list of dicts (alias for execute)."""
return self.execute(sql, params)
def fetch_one(self, sql: str, params: Optional[Dict] = None) -> Optional[Dict]:
"""Fetch first row as dict (alias for execute_one)."""
return self.execute_one(sql, params)
# Agent queries
def get_agents(self) -> List[Dict]:
"""Get all agents from database."""
return self.execute("""
SELECT * FROM public.agent_dashboard
ORDER BY id
""")
def get_agent(self, agent_id: int) -> Optional[Dict]:
"""Get agent by ID with full persona details."""
return self.execute_one("""
SELECT
a.*,
(SELECT COUNT(*) FROM memory.memories mem WHERE mem.agent_id = a.id AND mem.is_active = TRUE) AS memory_count,
(SELECT COUNT(*) FROM communication.chat_history ch WHERE ch.agent_id = a.id) AS message_count,
(SELECT COUNT(*) FROM circle.members cm WHERE cm.agent_id = a.id AND cm.is_active = TRUE) AS circle_count
FROM agent.agents_full a
WHERE a.id = %(id)s
""", {'id': agent_id})
# Provider queries
def get_providers(self) -> List[Dict]:
"""Get all providers."""
return self.execute("""
SELECT p.*,
COUNT(m.id) as model_count
FROM agent.providers p
LEFT JOIN agent.models m ON m.provider_id = p.id
GROUP BY p.id
ORDER BY p.id
""")
def get_provider(self, provider_id: int) -> Optional[Dict]:
"""Get provider by ID."""
return self.execute_one("""
SELECT * FROM agent.providers WHERE id = %(id)s
""", {'id': provider_id})
# Model queries
def get_models(self, provider_id: Optional[int] = None, include_deprecated: bool = False) -> List[Dict]:
"""Get all models, optionally filtered by provider."""
sql = """
SELECT m.*, p.name as provider_name
FROM agent.models m
JOIN agent.providers p ON p.id = m.provider_id
WHERE 1=1
"""
params: Dict[str, Any] = {}
if provider_id:
sql += " AND m.provider_id = %(provider_id)s"
params['provider_id'] = provider_id
if not include_deprecated:
sql += " AND m.is_deprecated = false"
sql += " ORDER BY p.name, m.model_alias"
return self.execute(sql, params)
def get_model(self, model_id: int) -> Optional[Dict]:
"""Get model by ID."""
return self.execute_one("""
SELECT m.*, p.name as provider_name
FROM agent.models m
JOIN agent.providers p ON p.id = m.provider_id
WHERE m.id = %(id)s
""", {'id': model_id})
# Persona queries
def get_personas(self) -> List[Dict]:
"""Get all personas."""
return self.execute("""
SELECT p.*, m.model_alias as default_model_alias
FROM agent.personas p
LEFT JOIN agent.models m ON m.id = p.default_model_id
ORDER BY p.id
""")
def get_persona(self, persona_id: int) -> Optional[Dict]:
"""Get persona by ID."""
return self.execute_one("""
SELECT p.*, m.model_alias as default_model_alias
FROM agent.personas p
LEFT JOIN agent.models m ON m.id = p.default_model_id
WHERE p.id = %(id)s
""", {'id': persona_id})
# Circle queries
def get_circles(self, is_active: Optional[bool] = None) -> List[Dict]:
"""Get all circles, optionally filtered by active status."""
sql = """
SELECT c.*,
COUNT(DISTINCT m.agent_id) as member_count,
COUNT(DISTINCT t.id) as task_count
FROM circle.circles c
LEFT JOIN circle.members m ON m.circle_id = c.id AND m.is_active = true
LEFT JOIN circle.tasks t ON t.circle_id = c.id
WHERE 1=1
"""
params: Dict[str, Any] = {}
if is_active is not None:
sql += " AND c.is_active = %(is_active)s"
params['is_active'] = is_active
sql += " GROUP BY c.id ORDER BY c.created_at DESC"
return self.execute(sql, params)
def get_circle(self, circle_id: int) -> Optional[Dict]:
"""Get circle by ID with member and task counts."""
return self.execute_one("""
SELECT c.*,
COUNT(DISTINCT m.agent_id) as member_count,
COUNT(DISTINCT t.id) as task_count
FROM circle.circles c
LEFT JOIN circle.members m ON m.circle_id = c.id AND m.is_active = true
LEFT JOIN circle.tasks t ON t.circle_id = c.id
WHERE c.id = %(id)s
GROUP BY c.id
""", {'id': circle_id})
def get_circle_members(self, circle_id: int) -> List[Dict]:
"""Get all active members of a circle."""
return self.execute("""
SELECT m.*, a.name as agent_name, a.role as agent_role
FROM circle.members m
JOIN agent.agents a ON a.id = m.agent_id
WHERE m.circle_id = %(circle_id)s AND m.is_active = true
ORDER BY m.joined_at
""", {'circle_id': circle_id})
def get_circle_tasks(self, circle_id: int, status: Optional[str] = None) -> List[Dict]:
"""Get tasks for a circle, optionally filtered by status."""
sql = """
SELECT t.*, a.name as assigned_agent_name
FROM circle.tasks t
LEFT JOIN agent.agents a ON a.id = t.assigned_agent_id
WHERE t.circle_id = %(circle_id)s
"""
params: Dict[str, Any] = {'circle_id': circle_id}
if status:
sql += " AND t.status = %(status)s::task_status"
params['status'] = status
sql += " ORDER BY t.priority DESC, t.created_at"
return self.execute(sql, params)
# Circle persistence methods
def get_circle_by_name(self, name: str) -> Optional[Dict]:
"""Get circle by name."""
return self.execute_one("""
SELECT c.*,
COUNT(DISTINCT m.agent_id) as member_count,
COUNT(DISTINCT t.id) as task_count
FROM circle.circles c
LEFT JOIN circle.members m ON m.circle_id = c.id AND m.is_active = true
LEFT JOIN circle.tasks t ON t.circle_id = c.id
WHERE c.name = %(name)s AND c.is_active = true
GROUP BY c.id
""", {'name': name})
def create_circle(self, name: str, require_review: bool = True, auto_route: bool = True) -> Optional[Dict]:
"""Create a new circle in the database."""
return self.execute_one("""
INSERT INTO circle.circles (name, display_name, require_review, auto_route, status)
VALUES (%(name)s, %(name)s, %(require_review)s, %(auto_route)s, 'stopped')
RETURNING *
""", {'name': name, 'require_review': require_review, 'auto_route': auto_route})
def update_circle_status(self, name: str, status: str) -> bool:
"""Update circle status."""
result = self.execute("""
UPDATE circle.circles
SET status = %(status)s::circle_status,
started_at = CASE WHEN %(status)s = 'running' THEN NOW() ELSE started_at END,
stopped_at = CASE WHEN %(status)s = 'stopped' THEN NOW() ELSE stopped_at END
WHERE name = %(name)s AND is_active = true
RETURNING id
""", {'name': name, 'status': status})
return len(result) > 0
def delete_circle(self, name: str) -> bool:
"""Soft delete a circle."""
result = self.execute("""
UPDATE circle.circles
SET is_active = false, stopped_at = NOW()
WHERE name = %(name)s AND is_active = true
RETURNING id
""", {'name': name})
return len(result) > 0
def add_circle_member(self, circle_name: str, agent_id: int, competencies: List[str] = None,
can_review: List[str] = None) -> Optional[Dict]:
"""Add an agent to a circle."""
circle = self.get_circle_by_name(circle_name)
if not circle:
return None
return self.execute_one("""
INSERT INTO circle.members (circle_id, agent_id, competencies, can_review)
VALUES (%(circle_id)s, %(agent_id)s, %(competencies)s, %(can_review)s)
ON CONFLICT (circle_id, agent_id) DO UPDATE SET
is_active = true,
competencies = EXCLUDED.competencies,
can_review = EXCLUDED.can_review
RETURNING *
""", {
'circle_id': circle['id'],
'agent_id': agent_id,
'competencies': competencies or [],
'can_review': can_review or []
})
def remove_circle_member(self, circle_name: str, agent_id: int) -> bool:
"""Remove an agent from a circle."""
circle = self.get_circle_by_name(circle_name)
if not circle:
return False
result = self.execute("""
UPDATE circle.members
SET is_active = false, left_at = NOW()
WHERE circle_id = %(circle_id)s AND agent_id = %(agent_id)s
RETURNING id
""", {'circle_id': circle['id'], 'agent_id': agent_id})
return len(result) > 0
def get_active_circles(self) -> List[Dict]:
"""Get all active circles with their members."""
return self.execute("""
SELECT c.*
FROM circle.circles c
WHERE c.is_active = true
ORDER BY c.created_at DESC
""")
def get_circle_members_with_info(self, circle_id: int) -> List[Dict]:
"""Get circle members with agent info."""
return self.execute("""
SELECT m.*, a.name as agent_name,
p.name as provider_name, mod.model_name, mod.model_alias
FROM circle.members m
JOIN agent.agents a ON a.id = m.agent_id
LEFT JOIN agent.models mod ON a.model_id = mod.id
LEFT JOIN agent.providers p ON mod.provider_id = p.id
WHERE m.circle_id = %(circle_id)s AND m.is_active = true
""", {'circle_id': circle_id})
def get_circle_members_full(self, circle_id: int) -> List[Dict]:
"""Get circle members with full agent details in a single JOIN query.
Eliminates N+1 queries by fetching member info, agent details,
system_prompt, skill_names, provider, and model in one shot.
"""
return self.execute("""
SELECT
m.id as member_id,
m.agent_id,
m.role,
m.is_active,
m.joined_at,
m.competencies,
m.can_review,
a.name as agent_name,
a.system_prompt,
a.base_prompt,
a.skill_names,
a.status as agent_status,
p.name as provider_name,
p.api_type as provider_api_type,
mod.model_name,
mod.model_alias
FROM circle.members m
JOIN agent.agents a ON a.id = m.agent_id
LEFT JOIN agent.models mod ON a.model_id = mod.id
LEFT JOIN agent.providers p ON mod.provider_id = p.id
WHERE m.circle_id = %(circle_id)s AND m.is_active = true
""", {'circle_id': circle_id})
# Conversation persistence methods
def create_conversation(self, conv_data: dict) -> Optional[Dict]:
"""Create a new conversation in the database."""
# Get circle_id from circle name if provided
circle_id = None
circle_name = conv_data.get('circle_name')
if circle_name:
circle = self.get_circle_by_name(circle_name)
if circle:
circle_id = circle['id']
return self.execute_one("""
INSERT INTO communication.conversations (
circle_id, topic, conversation_type, participant_agent_ids,
participant_names, max_turns, turn_strategy, initial_prompt,
status, turns_taken
)
VALUES (
%(circle_id)s, %(topic)s, 'collaboration', %(agent_ids)s,
%(participant_names)s, %(max_turns)s, %(turn_strategy)s,
%(initial_prompt)s, %(status)s, %(turns_taken)s
)
RETURNING *
""", {
'circle_id': circle_id,
'topic': conv_data.get('topic', ''),
'agent_ids': conv_data.get('agent_ids', []),
'participant_names': conv_data.get('participant_names', []),
'max_turns': conv_data.get('max_turns', 20),
'turn_strategy': conv_data.get('turn_strategy', 'round_robin'),
'initial_prompt': conv_data.get('initial_prompt'),
'status': conv_data.get('status', 'pending'),
'turns_taken': conv_data.get('turns_taken', 0),
})
def get_conversation(self, conv_id: int) -> Optional[Dict]:
"""Get a conversation by ID with its messages."""
conv = self.execute_one("""
SELECT c.*,
(SELECT COUNT(*) FROM communication.messages m WHERE m.conversation_id = c.id) as message_count
FROM communication.conversations c
WHERE c.id = %(id)s AND c.is_active = true
""", {'id': conv_id})
return conv
def get_conversation_messages(self, conv_id: int) -> List[Dict]:
"""Get all messages for a conversation."""
return self.execute("""
SELECT m.*
FROM communication.messages m
WHERE m.conversation_id = %(conv_id)s
ORDER BY m.created_at
""", {'conv_id': conv_id})
def add_conversation_message(self, conv_id: int, msg_data: dict) -> Optional[Dict]:
"""Add a message to a conversation."""
agent_id = msg_data.get('agent_id')
# agent_id 0 means user message
role = 'user' if agent_id == 0 else 'assistant'
return self.execute_one("""
INSERT INTO communication.messages (
conversation_id, role, agent_id, agent_name, content, mentions
)
VALUES (
%(conv_id)s, %(role)s::message_role, %(agent_id)s,
%(agent_name)s, %(content)s, %(mentions)s
)
RETURNING *
""", {
'conv_id': conv_id,
'role': role,
'agent_id': agent_id if agent_id and agent_id > 0 else None,
'agent_name': msg_data.get('agent_name', 'Unknown'),
'content': msg_data.get('content', ''),
'mentions': msg_data.get('mentions', []),
})
def update_conversation(self, conv_id: int, data: dict) -> bool:
"""Update a conversation."""
CONVERSATION_UPDATE_COLUMNS = {
"status", "turns_taken", "summary", "started_at", "completed_at",
}
update_dict = {}
for col in CONVERSATION_UPDATE_COLUMNS:
if col in data:
update_dict[col] = data[col]
if not update_dict:
return False
set_clause, params = safe_update_builder(
CONVERSATION_UPDATE_COLUMNS, update_dict,
)
params["id"] = conv_id
# Handle the conversation_status cast for status column
if "status" in update_dict:
set_clause = set_clause.replace(
"status = %(status)s", "status = %(status)s::conversation_status"
)
sql = f"UPDATE communication.conversations SET {set_clause} WHERE id = %(id)s RETURNING id"
result = self.execute(sql, params)
return len(result) > 0
def get_active_conversations(self) -> List[Dict]:
"""Get all active conversations."""
return self.execute("""
SELECT c.*,
(SELECT COUNT(*) FROM communication.messages m WHERE m.conversation_id = c.id) as message_count,
ci.name as circle_name
FROM communication.conversations c
LEFT JOIN circle.circles ci ON ci.id = c.circle_id
WHERE c.is_active = true
ORDER BY c.created_at DESC
""")
def delete_conversation(self, conv_id: int) -> bool:
"""Soft delete a conversation."""
result = self.execute("""
UPDATE communication.conversations
SET is_active = false
WHERE id = %(id)s
RETURNING id
""", {'id': conv_id})
return len(result) > 0
# Agent memory methods - for conversation history and task tracking
def get_agent_conversations(self, agent_id: int, limit: int = 10) -> List[Dict]:
"""Get recent conversations where an agent participated."""
return self.execute("""
SELECT DISTINCT
c.id,
c.topic,
c.status::TEXT as status,
c.turns_taken,
c.started_at,
c.completed_at,
c.summary,
(SELECT COUNT(*) FROM communication.messages m
WHERE m.conversation_id = c.id AND m.agent_id = %(agent_id)s) as my_message_count,
(SELECT COUNT(*) FROM communication.messages m
WHERE m.conversation_id = c.id) as total_messages
FROM communication.conversations c
JOIN communication.messages m ON m.conversation_id = c.id
WHERE m.agent_id = %(agent_id)s AND c.is_active = true
ORDER BY c.started_at DESC NULLS LAST
LIMIT %(limit)s
""", {'agent_id': agent_id, 'limit': limit})
def get_agent_conversation_messages(self, agent_id: int, limit: int = 50) -> List[Dict]:
"""Get recent messages sent by an agent across all conversations."""
return self.execute("""
SELECT
m.id,
m.conversation_id,
m.content,
m.created_at,
c.topic as conversation_topic
FROM communication.messages m
JOIN communication.conversations c ON c.id = m.conversation_id
WHERE m.agent_id = %(agent_id)s AND c.is_active = true
ORDER BY m.created_at DESC
LIMIT %(limit)s
""", {'agent_id': agent_id, 'limit': limit})
def get_agent_tasks(self, agent_id: int, limit: int = 20) -> List[Dict]:
"""Get tasks assigned to or completed by an agent."""
return self.execute("""
SELECT
t.id,
t.title,
t.description,
t.status::TEXT as status,
t.priority::TEXT as priority,
t.started_at,
t.completed_at,
t.result,
c.name as circle_name,
c.display_name as circle_display_name
FROM circle.tasks t
JOIN circle.circles c ON c.id = t.circle_id
WHERE t.assigned_agent_id = %(agent_id)s
ORDER BY t.created_at DESC
LIMIT %(limit)s
""", {'agent_id': agent_id, 'limit': limit})
def get_agent_recent_activity(self, agent_id: int) -> Dict[str, Any]:
"""Get a summary of recent agent activity for context injection."""
# Get counts
stats = self.execute_one("""
SELECT
(SELECT COUNT(*) FROM communication.messages m
WHERE m.agent_id = %(agent_id)s) as total_messages,
(SELECT COUNT(*) FROM circle.tasks t
WHERE t.assigned_agent_id = %(agent_id)s AND t.status = 'completed') as completed_tasks,
(SELECT COUNT(*) FROM circle.tasks t
WHERE t.assigned_agent_id = %(agent_id)s AND t.status = 'in_progress') as active_tasks,
(SELECT COUNT(DISTINCT c.id) FROM communication.conversations c
JOIN communication.messages m ON m.conversation_id = c.id
WHERE m.agent_id = %(agent_id)s) as conversations_participated
""", {'agent_id': agent_id}) or {}
# Get recent conversations (last 5)
recent_convs = self.get_agent_conversations(agent_id, limit=5)
# Get recent tasks (last 10)
recent_tasks = self.get_agent_tasks(agent_id, limit=10)
return {
'stats': stats,
'recent_conversations': recent_convs,
'recent_tasks': recent_tasks,
}
def build_agent_memory_context(activity: Dict[str, Any]) -> str:
"""Build a memory context string for injection into agent prompts.
Args:
activity: Dict from get_agent_recent_activity()
Returns:
Formatted string for inclusion in system prompt
"""
lines = ["## Mémoire et Historique"]
stats = activity.get('stats', {})
if stats:
lines.append("\n### Statistiques")
if stats.get('total_messages'):
lines.append(f"- Messages envoyés: {stats['total_messages']}")
if stats.get('completed_tasks'):
lines.append(f"- Tâches complétées: {stats['completed_tasks']}")
if stats.get('active_tasks'):
lines.append(f"- Tâches en cours: {stats['active_tasks']}")
if stats.get('conversations_participated'):
lines.append(f"- Conversations participées: {stats['conversations_participated']}")
# Recent conversations
recent_convs = activity.get('recent_conversations', [])
if recent_convs:
lines.append("\n### Conversations Récentes")
for conv in recent_convs[:5]:
topic = conv.get('topic') or 'Sans sujet'
status = conv.get('status', 'unknown')
my_msgs = conv.get('my_message_count', 0)
summary = conv.get('summary')
line = f"- [{status}] {topic}"
if my_msgs:
line += f" ({my_msgs} messages de ma part)"
lines.append(line)
if summary:
lines.append(f" Résumé: {summary[:200]}...")
# Recent tasks
recent_tasks = activity.get('recent_tasks', [])
if recent_tasks:
lines.append("\n### Tâches Récentes")
for task in recent_tasks[:10]:
title = task.get('title', 'Sans titre')
status = task.get('status', 'unknown')
circle = task.get('circle_display_name') or task.get('circle_name', '')
result = task.get('result')
line = f"- [{status}] {title}"
if circle:
line += f" (Circle: {circle})"
lines.append(line)
if result and status == 'completed':
# Truncate long results
result_preview = result[:150] + "..." if len(result) > 150 else result
lines.append(f" Résultat: {result_preview}")
if len(lines) == 1:
lines.append("\nAucun historique disponible pour le moment.")
return "\n".join(lines)
_db_service: Optional[DatabaseService] = None
@lru_cache()
def get_database_service() -> DatabaseService:
"""Get or create the database service singleton."""
global _db_service
if _db_service is None:
_db_service = DatabaseService()
return _db_service
class AgentRegistry:
"""Registry for managing agents across the API with database loading."""
def __init__(self, db: Optional[DatabaseService] = None):
self._agents: Dict[int, AgentWrapper] = {}
self._next_id: int = 1
self._db = db
self._loaded = False
def set_db(self, db: DatabaseService) -> None:
"""Set the database service (for lazy initialization)."""
self._db = db
def _ensure_loaded(self) -> None:
"""Ensure agents are loaded from database on first access."""
if self._loaded or not self._db:
return
self._loaded = True
self._load_from_db()
def _load_from_db(self) -> None:
"""Load all agents from database."""
if not self._db:
return
import logging
logger = logging.getLogger(__name__)
try:
agents_data = self._db.get_agents()
logger.info(f"Loading {len(agents_data)} agents from database")
from gathering.agents import AgentPersona, AgentConfig, AgentWrapper
from gathering.llm.providers import LLMProviderFactory
from gathering.core.config import get_settings
settings = get_settings()
memory = get_memory_service()
for agent_row in agents_data:
try:
agent_id = agent_row['id']
# Get full agent details
full_agent = self._db.get_agent(agent_id)
if not full_agent:
continue
# Create persona
persona = AgentPersona(
name=full_agent.get('name', f'Agent-{agent_id}'),
role=full_agent.get('role', 'Assistant'),
traits=full_agent.get('traits') or [],
communication_style=full_agent.get('communication_style', 'professional'),
specializations=full_agent.get('specializations') or [],
languages=full_agent.get('languages') or ['English'],
)
# Get provider and model info
provider_name = full_agent.get('provider_name', 'anthropic') or 'anthropic'
model_name = full_agent.get('model_alias') or full_agent.get('model_name') or 'claude-sonnet-4'
# Create config
config = AgentConfig(
provider=provider_name,
model=model_name,
max_tokens=full_agent.get('max_tokens') or 4096,
temperature=full_agent.get('temperature') or 0.7,
)
# Create LLM provider
api_key = settings.get_llm_api_key(provider_name)
llm = None
if api_key:
try:
llm = LLMProviderFactory.create(provider_name, {
"api_key": api_key,
"model": model_name,
"max_tokens": config.max_tokens,
"temperature": config.temperature,
})
except Exception as e:
logger.warning(f"Failed to create LLM for agent {agent_id}: {e}")
if not llm:
# Mock LLM fallback
class MockLLM:
def complete(self, messages, **kwargs):
return {"content": f"LLM not configured for {provider_name}"}
llm = MockLLM()
# Create agent wrapper
agent = AgentWrapper(
agent_id=agent_id,
persona=persona,
llm=llm,
memory=memory,
config=config,
)
# Load skills from database for this agent
try:
from gathering.skills.registry import SkillRegistry
from gathering.agents.project_context import load_project_context
# Get skill_names from the agent row in DB
skill_row = self._db.execute_one(
"SELECT skill_names FROM agent.agents WHERE id = %(id)s",
{'id': agent_id}
)
skill_names = skill_row.get('skill_names') or [] if skill_row else []
# Fallback to core skills if none configured
if not skill_names:
skill_names = ["filesystem", "git", "code"]
project_path = "/home/loc/workspace/gathering"
for skill_name in skill_names:
try:
skill = SkillRegistry.get(
skill_name,
config={"working_dir": project_path, "allowed_paths": [project_path]},
)
agent.add_skill(skill)
except Exception as skill_err:
logger.warning(f"Failed to load skill {skill_name} for agent {agent_id}: {skill_err}")
# Set default project context
project = load_project_context(project_name="gathering")
if project:
agent.set_project(project)
logger.debug(f"Set project context for agent {agent_id}")
except Exception as skill_err:
logger.warning(f"Failed to load skills for agent {agent_id}: {skill_err}")
self._agents[agent_id] = agent
if agent_id >= self._next_id:
self._next_id = agent_id + 1
logger.debug(f"Loaded agent {agent_id}: {persona.name} with skills")
except Exception as e:
logger.error(f"Failed to load agent {agent_row.get('id')}: {e}")
logger.info(f"Loaded {len(self._agents)} agents into registry")
except Exception as e:
import logging
logging.getLogger(__name__).error(f"Failed to load agents from database: {e}")
def add(self, agent: AgentWrapper) -> int:
"""Add an agent to the registry."""
self._ensure_loaded()
agent_id = agent.agent_id
self._agents[agent_id] = agent
if agent_id >= self._next_id:
self._next_id = agent_id + 1
return agent_id
def get(self, agent_id: int) -> Optional[AgentWrapper]:
"""Get an agent by ID."""
self._ensure_loaded()
return self._agents.get(agent_id)
def remove(self, agent_id: int) -> bool:
"""Remove an agent from the registry."""
self._ensure_loaded()
if agent_id in self._agents:
del self._agents[agent_id]
return True
return False
def list_all(self) -> list:
"""List all agents."""
self._ensure_loaded()
return list(self._agents.values())
def count(self) -> int:
"""Count agents."""
self._ensure_loaded()
return len(self._agents)
def next_id(self) -> int:
"""Get next available ID."""
self._ensure_loaded()
next_id = self._next_id
self._next_id += 1
return next_id
class CircleRegistry:
"""Registry for managing circles across the API with database persistence."""
def __init__(self, db: Optional[DatabaseService] = None):
self._circles: Dict[str, GatheringCircle] = {}
self._circle_metadata: Dict[str, Dict[str, Any]] = {} # Store DB metadata (project_id, etc.)
self._db = db
self._loaded = False
def set_db(self, db: DatabaseService) -> None:
"""Set the database service (for lazy initialization)."""
self._db = db
def _ensure_loaded(self) -> None:
"""Ensure circles are loaded from database on first access."""
if self._loaded or not self._db:
return
self._loaded = True
self._load_from_db()
def _load_from_db(self) -> None:
"""Load all active circles from database."""
if not self._db:
return
import logging
logger = logging.getLogger(__name__)
try:
circles_data = self._db.get_active_circles()
logger.info(f"Loading {len(circles_data)} circles from database")
for circle_row in circles_data:
try:
# Create GatheringCircle from DB data
circle = GatheringCircle(
name=circle_row['name'],
require_review=circle_row.get('require_review', True),
auto_route=circle_row.get('auto_route', True),
)
# Load members with full agent details in a single JOIN query
# (eliminates N+1: no per-member get_agent() or skill_names SELECT)
members = self._db.get_circle_members_full(circle_row['id'])
for member in members:
from gathering.orchestration import AgentHandle
from gathering.llm.providers import LLMProviderFactory
from gathering.core.config import get_settings
settings = get_settings()
provider_name = member.get('provider_name', 'anthropic') or 'anthropic'
model_name = member.get('model_name') or member.get('model_alias') or 'claude-sonnet-4'
api_key = settings.get_llm_api_key(provider_name)
process_message_callback = None
if api_key:
try:
llm_provider = LLMProviderFactory.create(provider_name, {
"api_key": api_key,
"model": model_name,
"max_tokens": 4096,
"temperature": 0.7,
})
agent_name_local = member['agent_name']
agent_id_local = member['agent_id']
# Extract system prompt and skills directly from JOIN result
system_prompt = member.get('system_prompt') or member.get('base_prompt')
skill_names = member.get('skill_names') or []
# Build full system prompt with project context and memory
from gathering.agents.project_context import GATHERING_PROJECT
project_context = GATHERING_PROJECT.to_prompt()
# Get agent's memory/activity context
agent_activity = self._db.get_agent_recent_activity(agent_id_local)
memory_context = build_agent_memory_context(agent_activity)
# Build skills info for system prompt
skills_info = ""
if skill_names:
skills_info = f"\n\n## Skills Disponibles\nTu as accès aux skills suivants: {', '.join(skill_names)}"
if system_prompt:
full_system_prompt = f"{system_prompt}\n\n## Contexte Projet\n{project_context}\n\n{memory_context}{skills_info}"
else:
full_system_prompt = f"""Tu es {agent_name_local}, un assistant IA expert.
## Contexte Projet
{project_context}
{memory_context}{skills_info}
Réponds de manière concise et constructive. Tu as accès au contexte du projet ci-dessus.
Tu peux référencer les fichiers, la structure, et les conventions du projet.
Tu peux aussi te référer à tes conversations et tâches passées dans ta mémoire.
Si tu as des skills disponibles, utilise les outils appropriés pour accomplir les tâches."""
# Create callback with skills support
process_message_callback = self._create_agent_callback_with_skills(
llm=llm_provider,
agent_name=agent_name_local,
system_prompt=full_system_prompt,
skill_names=skill_names,
logger=logger,
agent_id=member['agent_id'],
)
except Exception as e:
logger.warning(f"Failed to create LLM for agent {member['agent_id']}: {e}")
handle = AgentHandle(
id=member['agent_id'],
name=member['agent_name'],
provider=provider_name,
model=model_name,
competencies=member.get('competencies') or [],
can_review=member.get('can_review') or [],
process_message=process_message_callback,
)
circle.add_agent(handle)
self._circles[circle.name] = circle
# Store metadata from DB (project_id, etc.)
self._circle_metadata[circle.name] = {
'id': circle_row.get('id'),
'project_id': circle_row.get('project_id'),
}
logger.info(f"Loaded circle '{circle.name}' with {len(circle.agents)} agents")
except Exception as e:
logger.error(f"Failed to load circle {circle_row['name']}: {e}")
except Exception as e:
logger.error(f"Failed to load circles from database: {e}")
def _create_agent_callback_with_skills(
self,
llm,
agent_name: str,
system_prompt: str,
skill_names: List[str],
logger,
agent_id: int = None,
):
"""Create a callback function with skills support for an agent.
This enables agents to use tools during conversations.
"""
from gathering.skills.registry import SkillRegistry
# Agent context for skill traceability (e.g., git trailers)
agent_context = {
"agent_name": agent_name,
"agent_id": agent_id,
}
# Load tools from skills
tools = []
skill_tool_map = {} # tool_name -> skill_name
if skill_names:
try:
for skill_name in skill_names:
try:
skill = SkillRegistry.get(skill_name, config={
"working_dir": "/home/loc/workspace/gathering"
})
skill_tools = skill.get_tools_definition()
for tool in skill_tools:
tool_name = tool.get("name")
if tool_name:
skill_tool_map[tool_name] = skill_name
tools.extend(skill_tools)
logger.info(f"Loaded {len(skill_tools)} tools from skill '{skill_name}' for {agent_name}")
except Exception as e:
logger.warning(f"Could not load skill '{skill_name}' for {agent_name}: {e}")
except Exception as e:
logger.warning(f"Error loading skills for {agent_name}: {e}")
async def process_message(prompt: str) -> str:
"""Process a message with optional tool use."""
messages = [
{"role": "system", "content": system_prompt},
{"role": "user", "content": prompt},
]
# If no tools, simple completion
if not tools:
response = llm.complete(messages)
return response.get("content", "No response generated")
# With tools, do an agentic loop
max_iterations = 10
iteration = 0
while iteration < max_iterations:
iteration += 1
# Call LLM with tools
response = llm.complete(messages, tools=tools)
content = response.get("content", "")
tool_calls = response.get("tool_calls", [])
# If no tool calls, we're done
if not tool_calls:
return content if content else "No response generated"
# Log tool usage for debugging
logger.debug(f"[{agent_name}] Iteration {iteration}: {len(tool_calls)} tool call(s)")
# Add assistant message with tool calls
messages.append({
"role": "assistant",
"content": content or "",
"tool_calls": tool_calls,
})
# Execute each tool
for tool_call in tool_calls:
tool_id = tool_call.get("id", "")
tool_name = tool_call.get("name", "")
tool_args = tool_call.get("arguments", {})
# Find skill and execute tool
skill_name = skill_tool_map.get(tool_name)
result_str = ""
if skill_name:
try:
skill = SkillRegistry.get(skill_name, config={
"working_dir": "/home/loc/workspace/gathering"
})
# Pass agent context for traceability
skill.context = agent_context
result = skill.execute(tool_name, tool_args)
# Format result
if result.success:
if result.data:
import json
result_str = json.dumps(result.data, ensure_ascii=False, indent=2)
else:
result_str = result.message
else:
result_str = f"Error: {result.error or result.message}"
except Exception as e:
result_str = f"Tool execution error: {str(e)}"
else:
result_str = f"Unknown tool: {tool_name}"
# Add tool result to messages
messages.append({
"role": "tool",
"tool_use_id": tool_id,
"name": tool_name,
"content": result_str,
})
# If we hit max iterations, return last content with warning
logger.warning(f"[{agent_name}] Hit max tool iterations ({max_iterations})")
if content:
return content + f"\n\n[Limite de {max_iterations} itérations d'outils atteinte]"
return f"[Erreur: Limite de {max_iterations} itérations d'outils atteinte sans réponse finale]"
return process_message
def add(self, circle: GatheringCircle, persist: bool = True) -> str:
"""Add a circle to the registry and optionally persist to DB."""
self._ensure_loaded()
self._circles[circle.name] = circle
if persist and self._db:
# Persist to database
self._db.create_circle(
name=circle.name,
require_review=circle.require_review,
auto_route=circle.auto_route,
)
return circle.name
def get(self, name: str) -> Optional[GatheringCircle]:
"""Get a circle by name."""
self._ensure_loaded()
return self._circles.get(name)
def get_metadata(self, name: str) -> Dict[str, Any]:
"""Get circle metadata (project_id, etc.) by name."""
self._ensure_loaded()
return self._circle_metadata.get(name, {})
def get_project_name(self, name: str) -> Optional[str]:
"""Get the project name associated with a circle."""
metadata = self.get_metadata(name)
project_id = metadata.get('project_id')
if project_id and self._db:
project = self._db.get_project(project_id)
if project:
return project.get('name')
return None
def remove(self, name: str, persist: bool = True) -> bool:
"""Remove a circle from the registry and optionally from DB."""
self._ensure_loaded()
if name in self._circles:
del self._circles[name]
if persist and self._db:
self._db.delete_circle(name)
return True
return False
def update_status(self, name: str, status: str) -> bool:
"""Update circle status in database."""
if self._db:
return self._db.update_circle_status(name, status)
return False
def add_member(self, circle_name: str, agent_id: int, competencies: List[str] = None,
can_review: List[str] = None) -> bool:
"""Add a member to circle in database.
Note: If the agent doesn't exist in DB (e.g., in-memory only during tests),
the persistence is skipped silently. The in-memory circle still has the agent.
"""
if self._db:
try:
result = self._db.add_circle_member(circle_name, agent_id, competencies, can_review)
return result is not None
except Exception as e:
# Ignore FK violations - agent may exist in memory only (tests, dynamic agents)
import logging
logging.getLogger(__name__).debug(f"Could not persist circle member: {e}")
return False
return False
def remove_member(self, circle_name: str, agent_id: int) -> bool:
"""Remove a member from circle in database."""
if self._db:
return self._db.remove_circle_member(circle_name, agent_id)
return False
def list_all(self) -> list:
"""List all circles."""
self._ensure_loaded()
return list(self._circles.values())
def count(self) -> int:
"""Count circles."""
self._ensure_loaded()
return len(self._circles)
class ConversationRegistry:
"""Registry for managing conversations with database persistence."""
def __init__(self, db: Optional[DatabaseService] = None):
self._conversations: Dict[str, dict] = {}
self._db = db
self._loaded = False
def set_db(self, db: DatabaseService) -> None:
"""Set the database service (for lazy initialization)."""
self._db = db
def _ensure_loaded(self) -> None:
"""Ensure conversations are loaded from database on first access."""
if self._loaded or not self._db:
return
self._loaded = True
self._load_from_db()
def _load_from_db(self) -> None:
"""Load all active conversations from database."""
if not self._db:
return
import logging
logger = logging.getLogger(__name__)
try:
convs_data = self._db.get_active_conversations()
logger.info(f"Loading {len(convs_data)} conversations from database")
for conv_row in convs_data:
try:
conv_id = str(conv_row['id'])
# Load messages for this conversation
messages_data = self._db.get_conversation_messages(conv_row['id'])
messages = []
for msg in messages_data:
messages.append({
"agent_id": msg.get('agent_id') or 0,
"agent_name": msg.get('agent_name', 'User'),
"content": msg.get('content', ''),
"mentions": msg.get('mentions', []),
"timestamp": msg.get('created_at'),
})
# Convert DB row to conversation dict
conv_dict = {
"id": conv_id,
"db_id": conv_row['id'],
"topic": conv_row.get('topic', ''),
"agent_ids": conv_row.get('participant_agent_ids', []),
"participant_names": conv_row.get('participant_names', []),
"max_turns": conv_row.get('max_turns', 20),
"turn_strategy": conv_row.get('turn_strategy', 'round_robin'),
"initial_prompt": conv_row.get('initial_prompt'),
"circle_name": conv_row.get('circle_name'), # Loaded from JOIN
"status": conv_row.get('status', 'pending'),
"turns_taken": conv_row.get('turns_taken', 0),
"messages": messages,
"transcript": "",
"started_at": conv_row.get('started_at'),
"completed_at": conv_row.get('completed_at'),
"duration_seconds": 0,
}
self._conversations[conv_id] = conv_dict
logger.info(f"Loaded conversation {conv_id} with {len(messages)} messages")
except Exception as e:
logger.error(f"Failed to load conversation {conv_row.get('id')}: {e}")
except Exception as e:
import logging
logging.getLogger(__name__).error(f"Failed to load conversations from database: {e}")
def add(self, conversation_data: dict) -> str:
"""Add a conversation and persist to DB."""
self._ensure_loaded()
# Create in database first
if self._db:
db_conv = self._db.create_conversation(conversation_data)
if db_conv:
conv_id = str(db_conv['id'])
conversation_data["id"] = conv_id
conversation_data["db_id"] = db_conv['id']
else:
# Fallback to memory-only
conv_id = f"conv-{len(self._conversations) + 1}"
conversation_data["id"] = conv_id
else:
conv_id = f"conv-{len(self._conversations) + 1}"
conversation_data["id"] = conv_id
self._conversations[conv_id] = conversation_data
return conv_id
def get(self, conv_id: str) -> Optional[dict]:
"""Get a conversation by ID."""
self._ensure_loaded()
return self._conversations.get(conv_id)
def update(self, conv_id: str, data: dict) -> bool:
"""Update a conversation and persist to DB."""
self._ensure_loaded()
if conv_id not in self._conversations:
return False
conv = self._conversations[conv_id]
conv.update(data)
# Persist to DB
if self._db and 'db_id' in conv:
db_id = conv['db_id']
# Update conversation metadata
db_updates = {}
if 'status' in data:
status_val = data['status']
if hasattr(status_val, 'value'):
status_val = status_val.value
db_updates['status'] = status_val
if 'turns_taken' in data:
db_updates['turns_taken'] = data['turns_taken']
if 'started_at' in data:
db_updates['started_at'] = data['started_at']
if 'completed_at' in data:
db_updates['completed_at'] = data['completed_at']
if db_updates:
self._db.update_conversation(db_id, db_updates)
# If messages were updated, persist new ones
if 'messages' in data:
# Get existing message count
existing_msgs = self._db.get_conversation_messages(db_id)
existing_count = len(existing_msgs)
new_messages = data['messages'][existing_count:]
for msg in new_messages:
self._db.add_conversation_message(db_id, msg)
return True
def remove(self, conv_id: str) -> bool:
"""Remove a conversation."""
self._ensure_loaded()
if conv_id not in self._conversations:
return False
conv = self._conversations[conv_id]
if self._db and 'db_id' in conv:
self._db.delete_conversation(conv['db_id'])
del self._conversations[conv_id]
return True
def list_all(self) -> list:
"""List all conversations."""
self._ensure_loaded()
return list(self._conversations.values())
def count(self) -> int:
"""Count conversations."""
self._ensure_loaded()
return len(self._conversations)
# =============================================================================
# Data Source Toggle
# =============================================================================
def use_demo_data() -> bool:
"""Check if demo data should be used instead of database.
Returns True if USE_DEMO_DATA=true in .env, False otherwise.
When True, API returns hardcoded demo data for dashboard development.
When False, API queries PostgreSQL for real data.
"""
from dotenv import load_dotenv
load_dotenv()
return os.getenv("USE_DEMO_DATA", "true").lower() in ("true", "1", "yes")
# Demo data for dashboard development
DEMO_AGENTS = [
{
"id": 1,
"name": "Dr. Sophie Chen",
"role": "Lead AI Researcher",
"provider": "anthropic",
"model": "claude-sonnet-4-20250514",
"status": "idle",
"competencies": ["research", "analysis", "python", "machine-learning"],
"can_review": ["code", "documentation"],
"current_task": None,
"tasks_completed": 47,
"reviews_done": 23,
"approval_rate": 0.94,
"average_quality_score": 4.7,
"is_active": True,
},
{
"id": 2,
"name": "Olivia Nakamoto",
"role": "Full-Stack Developer",
"provider": "anthropic",
"model": "claude-sonnet-4-20250514",
"status": "busy",
"competencies": ["typescript", "react", "nodejs", "postgresql"],
"can_review": ["code", "architecture"],
"current_task": "Implementing dashboard components",
"tasks_completed": 89,
"reviews_done": 45,
"approval_rate": 0.91,
"average_quality_score": 4.5,
"is_active": True,
},
{
"id": 3,
"name": "Marcus Webb",
"role": "DevOps Engineer",
"provider": "openai",
"model": "gpt-4",
"status": "idle",
"competencies": ["docker", "kubernetes", "ci-cd", "aws"],
"can_review": ["infrastructure", "security"],
"current_task": None,
"tasks_completed": 34,
"reviews_done": 18,
"approval_rate": 0.88,
"average_quality_score": 4.3,
"is_active": True,
},
]
DEMO_PROVIDERS = [
{"id": 1, "name": "anthropic", "display_name": "Anthropic", "model_count": 3},
{"id": 2, "name": "openai", "display_name": "OpenAI", "model_count": 4},
{"id": 3, "name": "deepseek", "display_name": "DeepSeek", "model_count": 2},
{"id": 4, "name": "ollama", "display_name": "Ollama (Local)", "model_count": 5},
]
DEMO_MODELS = [
{"id": 1, "provider_id": 1, "provider_name": "anthropic", "model_alias": "claude-sonnet-4-20250514", "is_deprecated": False},
{"id": 2, "provider_id": 1, "provider_name": "anthropic", "model_alias": "claude-opus-4-20250514", "is_deprecated": False},
{"id": 3, "provider_id": 2, "provider_name": "openai", "model_alias": "gpt-4", "is_deprecated": False},
{"id": 4, "provider_id": 2, "provider_name": "openai", "model_alias": "gpt-4-turbo", "is_deprecated": False},
{"id": 5, "provider_id": 3, "provider_name": "deepseek", "model_alias": "deepseek-coder", "is_deprecated": False},
]
DEMO_CIRCLES = [
{
"id": 1,
"name": "ai-research",
"display_name": "AI Research Team",
"description": "Research and experimentation with LLMs and multi-agent systems",
"status": "running",
"auto_route": True,
"require_review": True,
"member_count": 2,
"task_count": 3,
"is_active": True,
},
{
"id": 2,
"name": "backend-team",
"display_name": "Backend Development",
"description": "API development, database optimization, and backend infrastructure",
"status": "running",
"auto_route": True,
"require_review": True,
"member_count": 2,
"task_count": 5,
"is_active": True,
},
{
"id": 3,
"name": "devops",
"display_name": "DevOps & Infrastructure",
"description": "CI/CD, deployment, monitoring, and infrastructure management",
"status": "stopped",
"auto_route": False,
"require_review": True,
"member_count": 1,
"task_count": 2,
"is_active": True,
},
]
DEMO_CIRCLE_MEMBERS = [
# ai-research members
{"id": 1, "circle_id": 1, "agent_id": 1, "agent_name": "Dr. Sophie Chen", "agent_role": "Lead AI Researcher", "role": "lead", "competencies": ["research", "analysis"], "is_active": True},
{"id": 2, "circle_id": 1, "agent_id": 2, "agent_name": "Olivia Nakamoto", "agent_role": "Full-Stack Developer", "role": "member", "competencies": ["python", "typescript"], "is_active": True},
# backend-team members
{"id": 3, "circle_id": 2, "agent_id": 2, "agent_name": "Olivia Nakamoto", "agent_role": "Full-Stack Developer", "role": "lead", "competencies": ["nodejs", "postgresql"], "is_active": True},
{"id": 4, "circle_id": 2, "agent_id": 1, "agent_name": "Dr. Sophie Chen", "agent_role": "Lead AI Researcher", "role": "member", "competencies": ["python"], "is_active": True},
# devops members
{"id": 5, "circle_id": 3, "agent_id": 3, "agent_name": "Marcus Webb", "agent_role": "DevOps Engineer", "role": "lead", "competencies": ["docker", "kubernetes"], "is_active": True},
]
DEMO_CIRCLE_TASKS = [
# ai-research tasks
{"id": 1, "circle_id": 1, "title": "Evaluate Claude Opus 4 for research tasks", "status": "in_progress", "priority": "high", "assigned_agent_id": 1, "assigned_agent_name": "Dr. Sophie Chen"},
{"id": 2, "circle_id": 1, "title": "Design multi-agent collaboration protocol", "status": "pending", "priority": "high", "assigned_agent_id": None, "assigned_agent_name": None},
{"id": 3, "circle_id": 1, "title": "Write paper on autonomous agent architectures", "status": "pending", "priority": "medium", "assigned_agent_id": None, "assigned_agent_name": None},
# backend-team tasks
{"id": 4, "circle_id": 2, "title": "Optimize PostgreSQL query performance", "status": "completed", "priority": "high", "assigned_agent_id": 2, "assigned_agent_name": "Olivia Nakamoto"},
{"id": 5, "circle_id": 2, "title": "Implement circle endpoints for dashboard", "status": "in_progress", "priority": "high", "assigned_agent_id": 2, "assigned_agent_name": "Olivia Nakamoto"},
{"id": 6, "circle_id": 2, "title": "Add WebSocket support for real-time updates", "status": "pending", "priority": "medium", "assigned_agent_id": None, "assigned_agent_name": None},
{"id": 7, "circle_id": 2, "title": "Create API documentation", "status": "pending", "priority": "low", "assigned_agent_id": None, "assigned_agent_name": None},
{"id": 8, "circle_id": 2, "title": "Implement rate limiting", "status": "completed", "priority": "medium", "assigned_agent_id": 1, "assigned_agent_name": "Dr. Sophie Chen"},
# devops tasks
{"id": 9, "circle_id": 3, "title": "Set up CI/CD pipeline", "status": "pending", "priority": "high", "assigned_agent_id": 3, "assigned_agent_name": "Marcus Webb"},
{"id": 10, "circle_id": 3, "title": "Configure monitoring and alerts", "status": "pending", "priority": "medium", "assigned_agent_id": None, "assigned_agent_name": None},
]
class DataService:
"""Service that returns demo or DB data based on USE_DEMO_DATA setting."""
def __init__(self, db_service: Optional[DatabaseService] = None):
self._db = db_service
@property
def is_demo_mode(self) -> bool:
return use_demo_data()
def get_agents(self) -> List[Dict]:
"""Get agents from demo data or database."""
if self.is_demo_mode:
return DEMO_AGENTS
if self._db:
return self._db.get_agents()
return DEMO_AGENTS # Fallback to demo if no DB
def get_agent(self, agent_id: int) -> Optional[Dict]:
"""Get agent by ID from demo data or database."""
if self.is_demo_mode:
return next((a for a in DEMO_AGENTS if a["id"] == agent_id), None)
if self._db:
return self._db.get_agent(agent_id)
return next((a for a in DEMO_AGENTS if a["id"] == agent_id), None)
def get_providers(self) -> List[Dict]:
"""Get providers from demo data or database."""
if self.is_demo_mode:
return DEMO_PROVIDERS
if self._db:
return self._db.get_providers()
return DEMO_PROVIDERS
def get_provider(self, provider_id: int) -> Optional[Dict]:
"""Get provider by ID from demo data or database."""
if self.is_demo_mode:
return next((p for p in DEMO_PROVIDERS if p["id"] == provider_id), None)
if self._db:
return self._db.get_provider(provider_id)
return next((p for p in DEMO_PROVIDERS if p["id"] == provider_id), None)
def get_models(self, provider_id: Optional[int] = None) -> List[Dict]:
"""Get models from demo data or database."""
if self.is_demo_mode:
models = DEMO_MODELS
if provider_id:
models = [m for m in models if m["provider_id"] == provider_id]
return models
if self._db:
return self._db.get_models(provider_id)
return DEMO_MODELS
def get_model(self, model_id: int) -> Optional[Dict]:
"""Get model by ID from demo data or database."""
if self.is_demo_mode:
return next((m for m in DEMO_MODELS if m["id"] == model_id), None)
if self._db:
return self._db.get_model(model_id)
return next((m for m in DEMO_MODELS if m["id"] == model_id), None)
def get_circles(self, is_active: Optional[bool] = None) -> List[Dict]:
"""Get circles from demo data or database."""
if self.is_demo_mode:
circles = DEMO_CIRCLES
if is_active is not None:
circles = [c for c in circles if c["is_active"] == is_active]
return circles
if self._db:
return self._db.get_circles(is_active)
return DEMO_CIRCLES
def get_circle(self, circle_id: int) -> Optional[Dict]:
"""Get circle by ID from demo data or database."""
if self.is_demo_mode:
return next((c for c in DEMO_CIRCLES if c["id"] == circle_id), None)
if self._db:
return self._db.get_circle(circle_id)
return next((c for c in DEMO_CIRCLES if c["id"] == circle_id), None)
def get_circle_members(self, circle_id: int) -> List[Dict]:
"""Get circle members from demo data or database."""
if self.is_demo_mode:
return [m for m in DEMO_CIRCLE_MEMBERS if m["circle_id"] == circle_id]
if self._db:
return self._db.get_circle_members(circle_id)
return [m for m in DEMO_CIRCLE_MEMBERS if m["circle_id"] == circle_id]
def get_circle_tasks(self, circle_id: int, status: Optional[str] = None) -> List[Dict]:
"""Get circle tasks from demo data or database."""
if self.is_demo_mode:
tasks = [t for t in DEMO_CIRCLE_TASKS if t["circle_id"] == circle_id]
if status:
tasks = [t for t in tasks if t["status"] == status]
return tasks
if self._db:
return self._db.get_circle_tasks(circle_id, status)
return [t for t in DEMO_CIRCLE_TASKS if t["circle_id"] == circle_id]
_data_service: Optional[DataService] = None
@lru_cache()
def get_data_service() -> DataService:
"""Get or create the data service singleton."""
global _data_service
if _data_service is None:
try:
db = get_database_service()
_data_service = DataService(db)
except Exception:
_data_service = DataService(None)
return _data_service
# =============================================================================
# Global instances (singleton pattern)
# =============================================================================
_memory_service: Optional[MemoryService] = None
_agent_registry: Optional[AgentRegistry] = None
_circle_registry: Optional[CircleRegistry] = None
_conversation_registry: Optional[ConversationRegistry] = None
@lru_cache()
def get_memory_service() -> MemoryService:
"""Get or create the global memory service.
Uses PostgresMemoryStore if database and OpenAI API key are configured,
otherwise falls back to InMemoryStore.
"""
global _memory_service
if _memory_service is None:
# Try to use PostgreSQL-backed store if configured
try:
if os.getenv("OPENAI_API_KEY") and (os.getenv("DATABASE_URL") or os.getenv("DB_HOST")):
from gathering.agents.postgres_store import PostgresMemoryStore
store = PostgresMemoryStore.from_env()
_memory_service = MemoryService(store=store)
print("MemoryService: Using PostgreSQL + pgvector")
else:
_memory_service = MemoryService()
print("MemoryService: Using InMemoryStore (no DB/OpenAI config)")
except Exception as e:
print(f"MemoryService: Falling back to InMemoryStore ({e})")
_memory_service = MemoryService()
return _memory_service
@lru_cache()
def get_agent_registry() -> AgentRegistry:
"""Get or create the global agent registry with database loading."""
global _agent_registry
if _agent_registry is None:
db = get_database_service()
_agent_registry = AgentRegistry(db=db)
return _agent_registry
@lru_cache()
def get_circle_registry() -> CircleRegistry:
"""Get or create the global circle registry with database persistence."""
global _circle_registry
if _circle_registry is None:
db = get_database_service()
_circle_registry = CircleRegistry(db=db)
return _circle_registry
@lru_cache()
def get_conversation_registry() -> ConversationRegistry:
"""Get or create the global conversation registry with database persistence."""
global _conversation_registry
if _conversation_registry is None:
db = get_database_service()
_conversation_registry = ConversationRegistry(db=db)
return _conversation_registry
def get_circle(name: str = "default") -> Optional[GatheringCircle]:
"""Get a circle by name."""
registry = get_circle_registry()
return registry.get(name)
def reset_registries():
"""Reset all registries (for testing)."""
global _memory_service, _agent_registry, _circle_registry, _conversation_registry, _data_service
_memory_service = None
_agent_registry = None
_circle_registry = None
_conversation_registry = None
_data_service = None
get_memory_service.cache_clear()
get_agent_registry.cache_clear()
get_circle_registry.cache_clear()
get_conversation_registry.cache_clear()
get_data_service.cache_clear()
"""
FastAPI dependencies for dependency injection.
"""
import os
from typing import Dict, Optional, List, Any
from functools import lru_cache
from gathering.orchestration import GatheringCircle
from gathering.agents import MemoryService, AgentWrapper
# Import pycopg (local PostgreSQL wrapper)
from pycopg import Database as PycopgDatabase, Config as PycopgConfig
from gathering.utils.sql import safe_update_builder
# =============================================================================
# Database Connection
# =============================================================================
class DatabaseService:
"""Database service for API using pycopg."""
_instance: Optional['DatabaseService'] = None
def get_instance(cls) -> 'DatabaseService':
"""Get or create the singleton DatabaseService instance."""
if cls._instance is None:
cls._instance = cls()
return cls._instance
def __init__(self):
from dotenv import load_dotenv
load_dotenv()
# Support DATABASE_URL (used in CI) or individual DB_* vars
database_url = os.getenv('DATABASE_URL')
if database_url:
# Parse postgresql://user:password@host:port/database
from urllib.parse import urlparse
parsed = urlparse(database_url)
self._config = PycopgConfig(
host=parsed.hostname or 'localhost',
port=parsed.port or 5432,
database=parsed.path.lstrip('/') or 'gathering',
user=parsed.username or 'postgres',
password=parsed.password or '',
)
else:
self._config = PycopgConfig(
host=os.getenv('DB_HOST', 'localhost'),
port=int(os.getenv('DB_PORT', '5432')),
database=os.getenv('DB_NAME', 'gathering'),
user=os.getenv('DB_USER', 'loc'),
password=os.getenv('DB_PASSWORD', ''),
)
self._db = PycopgDatabase(self._config)
def db(self) -> PycopgDatabase:
return self._db
def execute(self, sql: str, params: Optional[Dict] = None) -> List[Dict]:
"""Execute query and return list of dicts."""
result = self._db.execute(sql, params or {})
return list(result)
def execute_one(self, sql: str, params: Optional[Dict] = None) -> Optional[Dict]:
"""Execute query and return first row as dict."""
rows = self.execute(sql, params)
return rows[0] if rows else None
def fetch_all(self, sql: str, params: Optional[Dict] = None) -> List[Dict]:
"""Fetch all rows as list of dicts (alias for execute)."""
return self.execute(sql, params)
def fetch_one(self, sql: str, params: Optional[Dict] = None) -> Optional[Dict]:
"""Fetch first row as dict (alias for execute_one)."""
return self.execute_one(sql, params)
# Agent queries
def get_agents(self) -> List[Dict]:
"""Get all agents from database."""
return self.execute("""
SELECT * FROM public.agent_dashboard
ORDER BY id
""")
def get_agent(self, agent_id: int) -> Optional[Dict]:
"""Get agent by ID with full persona details."""
return self.execute_one("""
SELECT
a.*,
(SELECT COUNT(*) FROM memory.memories mem WHERE mem.agent_id = a.id AND mem.is_active = TRUE) AS memory_count,
(SELECT COUNT(*) FROM communication.chat_history ch WHERE ch.agent_id = a.id) AS message_count,
(SELECT COUNT(*) FROM circle.members cm WHERE cm.agent_id = a.id AND cm.is_active = TRUE) AS circle_count
FROM agent.agents_full a
Xet Storage Details
- Size:
- 70.6 kB
- Xet hash:
- 945c1b54593202418fe9c7bc856a2bb074abed1d20cd419d15e6f3724bbe3a41
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.