mirror of https://github.com/kortix-ai/suna.git
725 lines
27 KiB
Python
725 lines
27 KiB
Python
import json
|
|
from typing import List, Optional
|
|
from fastapi import APIRouter, HTTPException, Depends, UploadFile, File, Form, BackgroundTasks
|
|
from pydantic import BaseModel, Field, HttpUrl
|
|
from utils.auth_utils import get_current_user_id_from_jwt
|
|
from services.supabase import DBConnection
|
|
from knowledge_base.file_processor import FileProcessor
|
|
from utils.logger import logger
|
|
from flags.flags import is_enabled
|
|
|
|
router = APIRouter(prefix="/knowledge-base", tags=["knowledge-base"])
|
|
|
|
class KnowledgeBaseEntry(BaseModel):
|
|
entry_id: Optional[str] = None
|
|
name: str = Field(..., min_length=1, max_length=255)
|
|
description: Optional[str] = None
|
|
content: str = Field(..., min_length=1)
|
|
usage_context: str = Field(default="always", pattern="^(always|on_request|contextual)$")
|
|
is_active: bool = True
|
|
|
|
class KnowledgeBaseEntryResponse(BaseModel):
|
|
entry_id: str
|
|
name: str
|
|
description: Optional[str]
|
|
content: str
|
|
usage_context: str
|
|
is_active: bool
|
|
content_tokens: Optional[int]
|
|
created_at: str
|
|
updated_at: str
|
|
source_type: Optional[str] = None
|
|
source_metadata: Optional[dict] = None
|
|
file_size: Optional[int] = None
|
|
file_mime_type: Optional[str] = None
|
|
|
|
class KnowledgeBaseListResponse(BaseModel):
|
|
entries: List[KnowledgeBaseEntryResponse]
|
|
total_count: int
|
|
total_tokens: int
|
|
|
|
class CreateKnowledgeBaseEntryRequest(BaseModel):
|
|
name: str = Field(..., min_length=1, max_length=255)
|
|
description: Optional[str] = None
|
|
content: str = Field(..., min_length=1)
|
|
usage_context: str = Field(default="always", pattern="^(always|on_request|contextual)$")
|
|
|
|
class UpdateKnowledgeBaseEntryRequest(BaseModel):
|
|
name: Optional[str] = Field(None, min_length=1, max_length=255)
|
|
description: Optional[str] = None
|
|
content: Optional[str] = Field(None, min_length=1)
|
|
usage_context: Optional[str] = Field(None, pattern="^(always|on_request|contextual)$")
|
|
is_active: Optional[bool] = None
|
|
|
|
class GitRepositoryRequest(BaseModel):
|
|
git_url: HttpUrl
|
|
branch: str = "main"
|
|
include_patterns: Optional[List[str]] = None
|
|
exclude_patterns: Optional[List[str]] = None
|
|
|
|
class ProcessingJobResponse(BaseModel):
|
|
job_id: str
|
|
job_type: str
|
|
status: str
|
|
source_info: dict
|
|
result_info: dict
|
|
entries_created: int
|
|
total_files: int
|
|
created_at: str
|
|
completed_at: Optional[str]
|
|
error_message: Optional[str]
|
|
|
|
db = DBConnection()
|
|
|
|
@router.get("/threads/{thread_id}", response_model=KnowledgeBaseListResponse)
|
|
async def get_thread_knowledge_base(
|
|
thread_id: str,
|
|
include_inactive: bool = False,
|
|
user_id: str = Depends(get_current_user_id_from_jwt)
|
|
):
|
|
if not await is_enabled("knowledge_base"):
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="This feature is not available at the moment."
|
|
)
|
|
|
|
"""Get all knowledge base entries for a thread"""
|
|
try:
|
|
client = await db.client
|
|
|
|
thread_result = await client.table('threads').select('*').eq('thread_id', thread_id).execute()
|
|
if not thread_result.data:
|
|
raise HTTPException(status_code=404, detail="Thread not found")
|
|
|
|
result = await client.rpc('get_thread_knowledge_base', {
|
|
'p_thread_id': thread_id,
|
|
'p_include_inactive': include_inactive
|
|
}).execute()
|
|
|
|
entries = []
|
|
total_tokens = 0
|
|
|
|
for entry_data in result.data or []:
|
|
entry = KnowledgeBaseEntryResponse(
|
|
entry_id=entry_data['entry_id'],
|
|
name=entry_data['name'],
|
|
description=entry_data['description'],
|
|
content=entry_data['content'],
|
|
usage_context=entry_data['usage_context'],
|
|
is_active=entry_data['is_active'],
|
|
content_tokens=entry_data.get('content_tokens'),
|
|
created_at=entry_data['created_at'],
|
|
updated_at=entry_data.get('updated_at', entry_data['created_at'])
|
|
)
|
|
entries.append(entry)
|
|
total_tokens += entry_data.get('content_tokens', 0) or 0
|
|
|
|
return KnowledgeBaseListResponse(
|
|
entries=entries,
|
|
total_count=len(entries),
|
|
total_tokens=total_tokens
|
|
)
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting knowledge base for thread {thread_id}: {str(e)}")
|
|
raise HTTPException(status_code=500, detail="Failed to retrieve knowledge base")
|
|
|
|
@router.post("/threads/{thread_id}", response_model=KnowledgeBaseEntryResponse)
|
|
async def create_knowledge_base_entry(
|
|
thread_id: str,
|
|
entry_data: CreateKnowledgeBaseEntryRequest,
|
|
user_id: str = Depends(get_current_user_id_from_jwt)
|
|
):
|
|
if not await is_enabled("knowledge_base"):
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="This feature is not available at the moment."
|
|
)
|
|
|
|
"""Create a new knowledge base entry for a thread"""
|
|
try:
|
|
client = await db.client
|
|
thread_result = await client.table('threads').select('account_id').eq('thread_id', thread_id).execute()
|
|
if not thread_result.data:
|
|
raise HTTPException(status_code=404, detail="Thread not found")
|
|
|
|
account_id = thread_result.data[0]['account_id']
|
|
|
|
insert_data = {
|
|
'thread_id': thread_id,
|
|
'account_id': account_id,
|
|
'name': entry_data.name,
|
|
'description': entry_data.description,
|
|
'content': entry_data.content,
|
|
'usage_context': entry_data.usage_context
|
|
}
|
|
|
|
result = await client.table('knowledge_base_entries').insert(insert_data).execute()
|
|
|
|
if not result.data:
|
|
raise HTTPException(status_code=500, detail="Failed to create knowledge base entry")
|
|
|
|
created_entry = result.data[0]
|
|
|
|
return KnowledgeBaseEntryResponse(
|
|
entry_id=created_entry['entry_id'],
|
|
name=created_entry['name'],
|
|
description=created_entry['description'],
|
|
content=created_entry['content'],
|
|
usage_context=created_entry['usage_context'],
|
|
is_active=created_entry['is_active'],
|
|
content_tokens=created_entry.get('content_tokens'),
|
|
created_at=created_entry['created_at'],
|
|
updated_at=created_entry['updated_at']
|
|
)
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error creating knowledge base entry for thread {thread_id}: {str(e)}")
|
|
raise HTTPException(status_code=500, detail="Failed to create knowledge base entry")
|
|
|
|
@router.get("/agents/{agent_id}", response_model=KnowledgeBaseListResponse)
|
|
async def get_agent_knowledge_base(
|
|
agent_id: str,
|
|
include_inactive: bool = False,
|
|
user_id: str = Depends(get_current_user_id_from_jwt)
|
|
):
|
|
if not await is_enabled("knowledge_base"):
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="This feature is not available at the moment."
|
|
)
|
|
|
|
"""Get all knowledge base entries for an agent"""
|
|
try:
|
|
client = await db.client
|
|
|
|
agent_result = await client.table('agents').select('*').eq('agent_id', agent_id).eq('account_id', user_id).execute()
|
|
if not agent_result.data:
|
|
raise HTTPException(status_code=404, detail="Agent not found or access denied")
|
|
|
|
result = await client.rpc('get_agent_knowledge_base', {
|
|
'p_agent_id': agent_id,
|
|
'p_include_inactive': include_inactive
|
|
}).execute()
|
|
|
|
entries = []
|
|
total_tokens = 0
|
|
|
|
for entry_data in result.data or []:
|
|
entry = KnowledgeBaseEntryResponse(
|
|
entry_id=entry_data['entry_id'],
|
|
name=entry_data['name'],
|
|
description=entry_data['description'],
|
|
content=entry_data['content'],
|
|
usage_context=entry_data['usage_context'],
|
|
is_active=entry_data['is_active'],
|
|
content_tokens=entry_data.get('content_tokens'),
|
|
created_at=entry_data['created_at'],
|
|
updated_at=entry_data.get('updated_at', entry_data['created_at']),
|
|
source_type=entry_data.get('source_type'),
|
|
source_metadata=entry_data.get('source_metadata'),
|
|
file_size=entry_data.get('file_size'),
|
|
file_mime_type=entry_data.get('file_mime_type')
|
|
)
|
|
entries.append(entry)
|
|
total_tokens += entry_data.get('content_tokens', 0) or 0
|
|
|
|
return KnowledgeBaseListResponse(
|
|
entries=entries,
|
|
total_count=len(entries),
|
|
total_tokens=total_tokens
|
|
)
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting knowledge base for agent {agent_id}: {str(e)}")
|
|
raise HTTPException(status_code=500, detail="Failed to retrieve agent knowledge base")
|
|
|
|
@router.post("/agents/{agent_id}", response_model=KnowledgeBaseEntryResponse)
|
|
async def create_agent_knowledge_base_entry(
|
|
agent_id: str,
|
|
entry_data: CreateKnowledgeBaseEntryRequest,
|
|
user_id: str = Depends(get_current_user_id_from_jwt)
|
|
):
|
|
if not await is_enabled("knowledge_base"):
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="This feature is not available at the moment."
|
|
)
|
|
|
|
"""Create a new knowledge base entry for an agent"""
|
|
try:
|
|
client = await db.client
|
|
|
|
agent_result = await client.table('agents').select('account_id').eq('agent_id', agent_id).eq('account_id', user_id).execute()
|
|
if not agent_result.data:
|
|
raise HTTPException(status_code=404, detail="Agent not found or access denied")
|
|
|
|
account_id = agent_result.data[0]['account_id']
|
|
|
|
insert_data = {
|
|
'agent_id': agent_id,
|
|
'account_id': account_id,
|
|
'name': entry_data.name,
|
|
'description': entry_data.description,
|
|
'content': entry_data.content,
|
|
'usage_context': entry_data.usage_context
|
|
}
|
|
|
|
result = await client.table('agent_knowledge_base_entries').insert(insert_data).execute()
|
|
|
|
if not result.data:
|
|
raise HTTPException(status_code=500, detail="Failed to create agent knowledge base entry")
|
|
|
|
created_entry = result.data[0]
|
|
|
|
return KnowledgeBaseEntryResponse(
|
|
entry_id=created_entry['entry_id'],
|
|
name=created_entry['name'],
|
|
description=created_entry['description'],
|
|
content=created_entry['content'],
|
|
usage_context=created_entry['usage_context'],
|
|
is_active=created_entry['is_active'],
|
|
content_tokens=created_entry.get('content_tokens'),
|
|
created_at=created_entry['created_at'],
|
|
updated_at=created_entry['updated_at']
|
|
)
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error creating knowledge base entry for agent {agent_id}: {str(e)}")
|
|
raise HTTPException(status_code=500, detail="Failed to create agent knowledge base entry")
|
|
|
|
@router.post("/agents/{agent_id}/upload-file")
|
|
async def upload_file_to_agent_kb(
|
|
agent_id: str,
|
|
background_tasks: BackgroundTasks,
|
|
file: UploadFile = File(...),
|
|
user_id: str = Depends(get_current_user_id_from_jwt)
|
|
):
|
|
if not await is_enabled("knowledge_base"):
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="This feature is not available at the moment."
|
|
)
|
|
|
|
"""Upload and process a file for agent knowledge base"""
|
|
try:
|
|
client = await db.client
|
|
|
|
agent_result = await client.table('agents').select('account_id').eq('agent_id', agent_id).eq('account_id', user_id).execute()
|
|
if not agent_result.data:
|
|
raise HTTPException(status_code=404, detail="Agent not found or access denied")
|
|
|
|
account_id = agent_result.data[0]['account_id']
|
|
|
|
file_content = await file.read()
|
|
job_id = await client.rpc('create_agent_kb_processing_job', {
|
|
'p_agent_id': agent_id,
|
|
'p_account_id': account_id,
|
|
'p_job_type': 'file_upload',
|
|
'p_source_info': {
|
|
'filename': file.filename,
|
|
'mime_type': file.content_type,
|
|
'file_size': len(file_content)
|
|
}
|
|
}).execute()
|
|
|
|
if not job_id.data:
|
|
raise HTTPException(status_code=500, detail="Failed to create processing job")
|
|
|
|
job_id = job_id.data
|
|
background_tasks.add_task(
|
|
process_file_background,
|
|
job_id,
|
|
agent_id,
|
|
account_id,
|
|
file_content,
|
|
file.filename,
|
|
file.content_type or 'application/octet-stream'
|
|
)
|
|
|
|
return {
|
|
"job_id": job_id,
|
|
"message": "File upload started. Processing in background.",
|
|
"filename": file.filename
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error uploading file to agent {agent_id}: {str(e)}")
|
|
raise HTTPException(status_code=500, detail="Failed to upload file")
|
|
|
|
|
|
@router.get("/agents/{agent_id}/processing-jobs", response_model=List[ProcessingJobResponse])
|
|
async def get_agent_processing_jobs(
|
|
agent_id: str,
|
|
limit: int = 10,
|
|
user_id: str = Depends(get_current_user_id_from_jwt)
|
|
):
|
|
if not await is_enabled("knowledge_base"):
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="This feature is not available at the moment."
|
|
)
|
|
|
|
"""Get processing jobs for an agent"""
|
|
try:
|
|
client = await db.client
|
|
|
|
agent_result = await client.table('agents').select('account_id').eq('agent_id', agent_id).eq('account_id', user_id).execute()
|
|
if not agent_result.data:
|
|
raise HTTPException(status_code=404, detail="Agent not found or access denied")
|
|
|
|
result = await client.rpc('get_agent_kb_processing_jobs', {
|
|
'p_agent_id': agent_id,
|
|
'p_limit': limit
|
|
}).execute()
|
|
|
|
jobs = []
|
|
for job_data in result.data or []:
|
|
job = ProcessingJobResponse(
|
|
job_id=job_data['job_id'],
|
|
job_type=job_data['job_type'],
|
|
status=job_data['status'],
|
|
source_info=job_data['source_info'],
|
|
result_info=job_data['result_info'],
|
|
entries_created=job_data['entries_created'],
|
|
total_files=job_data['total_files'],
|
|
created_at=job_data['created_at'],
|
|
completed_at=job_data.get('completed_at'),
|
|
error_message=job_data.get('error_message')
|
|
)
|
|
jobs.append(job)
|
|
|
|
return jobs
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting processing jobs for agent {agent_id}: {str(e)}")
|
|
raise HTTPException(status_code=500, detail="Failed to get processing jobs")
|
|
|
|
async def process_file_background(
|
|
job_id: str,
|
|
agent_id: str,
|
|
account_id: str,
|
|
file_content: bytes,
|
|
filename: str,
|
|
mime_type: str
|
|
):
|
|
"""Background task to process uploaded files"""
|
|
|
|
processor = FileProcessor()
|
|
client = await processor.db.client
|
|
try:
|
|
await client.rpc('update_agent_kb_job_status', {
|
|
'p_job_id': job_id,
|
|
'p_status': 'processing'
|
|
}).execute()
|
|
|
|
result = await processor.process_file_upload(
|
|
agent_id, account_id, file_content, filename, mime_type
|
|
)
|
|
|
|
if result['success']:
|
|
await client.rpc('update_agent_kb_job_status', {
|
|
'p_job_id': job_id,
|
|
'p_status': 'completed',
|
|
'p_result_info': result,
|
|
'p_entries_created': 1,
|
|
'p_total_files': 1
|
|
}).execute()
|
|
else:
|
|
await client.rpc('update_agent_kb_job_status', {
|
|
'p_job_id': job_id,
|
|
'p_status': 'failed',
|
|
'p_error_message': result.get('error', 'Unknown error')
|
|
}).execute()
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error in background file processing for job {job_id}: {str(e)}")
|
|
try:
|
|
await client.rpc('update_agent_kb_job_status', {
|
|
'p_job_id': job_id,
|
|
'p_status': 'failed',
|
|
'p_error_message': str(e)
|
|
}).execute()
|
|
except:
|
|
pass
|
|
|
|
|
|
@router.get("/agents/{agent_id}/context")
|
|
async def get_agent_knowledge_base_context(
|
|
agent_id: str,
|
|
max_tokens: int = 4000,
|
|
user_id: str = Depends(get_current_user_id_from_jwt)
|
|
):
|
|
if not await is_enabled("knowledge_base"):
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="This feature is not available at the moment."
|
|
)
|
|
|
|
"""Get knowledge base context for agent prompts"""
|
|
try:
|
|
client = await db.client
|
|
|
|
agent_result = await client.table('agents').select('agent_id').eq('agent_id', agent_id).eq('account_id', user_id).execute()
|
|
if not agent_result.data:
|
|
raise HTTPException(status_code=404, detail="Agent not found or access denied")
|
|
|
|
result = await client.rpc('get_agent_knowledge_base_context', {
|
|
'p_agent_id': agent_id,
|
|
'p_max_tokens': max_tokens
|
|
}).execute()
|
|
|
|
context = result.data if result.data else None
|
|
|
|
return {
|
|
"context": context,
|
|
"max_tokens": max_tokens,
|
|
"agent_id": agent_id
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting knowledge base context for agent {agent_id}: {str(e)}")
|
|
raise HTTPException(status_code=500, detail="Failed to retrieve agent knowledge base context")
|
|
|
|
@router.put("/{entry_id}", response_model=KnowledgeBaseEntryResponse)
|
|
async def update_knowledge_base_entry(
|
|
entry_id: str,
|
|
entry_data: UpdateKnowledgeBaseEntryRequest,
|
|
user_id: str = Depends(get_current_user_id_from_jwt)
|
|
):
|
|
if not await is_enabled("knowledge_base"):
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="This feature is not available at the moment."
|
|
)
|
|
|
|
"""Update a knowledge base entry (works for both thread and agent entries)"""
|
|
try:
|
|
client = await db.client
|
|
entry_result = await client.table('knowledge_base_entries').select('*').eq('entry_id', entry_id).execute()
|
|
table_name = 'knowledge_base_entries'
|
|
|
|
if not entry_result.data:
|
|
entry_result = await client.table('agent_knowledge_base_entries').select('*').eq('entry_id', entry_id).execute()
|
|
table_name = 'agent_knowledge_base_entries'
|
|
|
|
if not entry_result.data:
|
|
raise HTTPException(status_code=404, detail="Knowledge base entry not found")
|
|
|
|
update_data = {}
|
|
if entry_data.name is not None:
|
|
update_data['name'] = entry_data.name
|
|
if entry_data.description is not None:
|
|
update_data['description'] = entry_data.description
|
|
if entry_data.content is not None:
|
|
update_data['content'] = entry_data.content
|
|
if entry_data.usage_context is not None:
|
|
update_data['usage_context'] = entry_data.usage_context
|
|
if entry_data.is_active is not None:
|
|
update_data['is_active'] = entry_data.is_active
|
|
|
|
if not update_data:
|
|
raise HTTPException(status_code=400, detail="No fields to update")
|
|
|
|
result = await client.table(table_name).update(update_data).eq('entry_id', entry_id).execute()
|
|
|
|
if not result.data:
|
|
raise HTTPException(status_code=500, detail="Failed to update knowledge base entry")
|
|
|
|
updated_entry = result.data[0]
|
|
|
|
return KnowledgeBaseEntryResponse(
|
|
entry_id=updated_entry['entry_id'],
|
|
name=updated_entry['name'],
|
|
description=updated_entry['description'],
|
|
content=updated_entry['content'],
|
|
usage_context=updated_entry['usage_context'],
|
|
is_active=updated_entry['is_active'],
|
|
content_tokens=updated_entry.get('content_tokens'),
|
|
created_at=updated_entry['created_at'],
|
|
updated_at=updated_entry['updated_at'],
|
|
source_type=updated_entry.get('source_type'),
|
|
source_metadata=updated_entry.get('source_metadata'),
|
|
file_size=updated_entry.get('file_size'),
|
|
file_mime_type=updated_entry.get('file_mime_type')
|
|
)
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error updating knowledge base entry {entry_id}: {str(e)}")
|
|
raise HTTPException(status_code=500, detail="Failed to update knowledge base entry")
|
|
|
|
@router.delete("/{entry_id}")
|
|
async def delete_knowledge_base_entry(
|
|
entry_id: str,
|
|
user_id: str = Depends(get_current_user_id_from_jwt)
|
|
):
|
|
if not await is_enabled("knowledge_base"):
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="This feature is not available at the moment."
|
|
)
|
|
|
|
"""Delete a knowledge base entry (works for both thread and agent entries)"""
|
|
try:
|
|
client = await db.client
|
|
|
|
entry_result = await client.table('knowledge_base_entries').select('entry_id').eq('entry_id', entry_id).execute()
|
|
table_name = 'knowledge_base_entries'
|
|
|
|
if not entry_result.data:
|
|
entry_result = await client.table('agent_knowledge_base_entries').select('entry_id').eq('entry_id', entry_id).execute()
|
|
table_name = 'agent_knowledge_base_entries'
|
|
|
|
if not entry_result.data:
|
|
raise HTTPException(status_code=404, detail="Knowledge base entry not found")
|
|
|
|
result = await client.table(table_name).delete().eq('entry_id', entry_id).execute()
|
|
|
|
return {"message": "Knowledge base entry deleted successfully"}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error deleting knowledge base entry {entry_id}: {str(e)}")
|
|
raise HTTPException(status_code=500, detail="Failed to delete knowledge base entry")
|
|
|
|
@router.get("/{entry_id}", response_model=KnowledgeBaseEntryResponse)
|
|
async def get_knowledge_base_entry(
|
|
entry_id: str,
|
|
user_id: str = Depends(get_current_user_id_from_jwt)
|
|
):
|
|
if not await is_enabled("knowledge_base"):
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="This feature is not available at the moment."
|
|
)
|
|
"""Get a specific knowledge base entry (works for both thread and agent entries)"""
|
|
try:
|
|
client = await db.client
|
|
|
|
result = await client.table('knowledge_base_entries').select('*').eq('entry_id', entry_id).execute()
|
|
|
|
if not result.data:
|
|
result = await client.table('agent_knowledge_base_entries').select('*').eq('entry_id', entry_id).execute()
|
|
|
|
if not result.data:
|
|
raise HTTPException(status_code=404, detail="Knowledge base entry not found")
|
|
|
|
entry = result.data[0]
|
|
|
|
return KnowledgeBaseEntryResponse(
|
|
entry_id=entry['entry_id'],
|
|
name=entry['name'],
|
|
description=entry['description'],
|
|
content=entry['content'],
|
|
usage_context=entry['usage_context'],
|
|
is_active=entry['is_active'],
|
|
content_tokens=entry.get('content_tokens'),
|
|
created_at=entry['created_at'],
|
|
updated_at=entry['updated_at'],
|
|
source_type=entry.get('source_type'),
|
|
source_metadata=entry.get('source_metadata'),
|
|
file_size=entry.get('file_size'),
|
|
file_mime_type=entry.get('file_mime_type')
|
|
)
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting knowledge base entry {entry_id}: {str(e)}")
|
|
raise HTTPException(status_code=500, detail="Failed to retrieve knowledge base entry")
|
|
|
|
@router.get("/threads/{thread_id}/context")
|
|
async def get_knowledge_base_context(
|
|
thread_id: str,
|
|
max_tokens: int = 4000,
|
|
user_id: str = Depends(get_current_user_id_from_jwt)
|
|
):
|
|
if not await is_enabled("knowledge_base"):
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="This feature is not available at the moment."
|
|
)
|
|
|
|
"""Get knowledge base context for agent prompts"""
|
|
try:
|
|
client = await db.client
|
|
thread_result = await client.table('threads').select('thread_id').eq('thread_id', thread_id).execute()
|
|
if not thread_result.data:
|
|
raise HTTPException(status_code=404, detail="Thread not found")
|
|
|
|
result = await client.rpc('get_knowledge_base_context', {
|
|
'p_thread_id': thread_id,
|
|
'p_max_tokens': max_tokens
|
|
}).execute()
|
|
|
|
context = result.data if result.data else None
|
|
|
|
return {
|
|
"context": context,
|
|
"max_tokens": max_tokens,
|
|
"thread_id": thread_id
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting knowledge base context for thread {thread_id}: {str(e)}")
|
|
raise HTTPException(status_code=500, detail="Failed to retrieve knowledge base context")
|
|
|
|
@router.get("/threads/{thread_id}/combined-context")
|
|
async def get_combined_knowledge_base_context(
|
|
thread_id: str,
|
|
agent_id: Optional[str] = None,
|
|
max_tokens: int = 4000,
|
|
user_id: str = Depends(get_current_user_id_from_jwt)
|
|
):
|
|
if not await is_enabled("knowledge_base"):
|
|
raise HTTPException(
|
|
status_code=403,
|
|
detail="This feature is not available at the moment."
|
|
)
|
|
|
|
"""Get combined knowledge base context from both thread and agent sources"""
|
|
try:
|
|
client = await db.client
|
|
thread_result = await client.table('threads').select('thread_id').eq('thread_id', thread_id).execute()
|
|
if not thread_result.data:
|
|
raise HTTPException(status_code=404, detail="Thread not found")
|
|
|
|
result = await client.rpc('get_combined_knowledge_base_context', {
|
|
'p_thread_id': thread_id,
|
|
'p_agent_id': agent_id,
|
|
'p_max_tokens': max_tokens
|
|
}).execute()
|
|
|
|
context = result.data if result.data else None
|
|
|
|
return {
|
|
"context": context,
|
|
"max_tokens": max_tokens,
|
|
"thread_id": thread_id,
|
|
"agent_id": agent_id
|
|
}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error getting combined knowledge base context for thread {thread_id}: {str(e)}")
|
|
raise HTTPException(status_code=500, detail="Failed to retrieve combined knowledge base context") |