OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.
Python
"""
Public API v1 Documents endpoint.
Provides document ingestion and management.
Uses API key authentication.
"""
from fastapi import Depends, File, Form, Request, UploadFile
from fastapi.responses import JSONResponse
from pydantic import BaseModel
from api.documents import delete_documents_by_filename_core
from api.router import upload_ingest_router
from api.v1._filter_resolution import resolve_filter_id
from dependencies import (
get_document_service,
get_knowledge_filter_service,
get_langflow_file_service,
get_rbac_service,
get_session_manager,
get_task_service,
has_effective_permission,
require_api_key_any_permission,
require_api_key_permission,
)
from session_manager import User
from utils.logging_config import get_logger
logger = get_logger(__name__)
require_document_delete_permission = require_api_key_any_permission(
("knowledge:delete:own", "knowledge:delete:anonymous")
)
class DeleteDocV1Body(BaseModel):
filename: str | None = None
filter_id: str | None = None
async def ingest_endpoint(
request: Request,
file: list[UploadFile] = File(...),
session_id: str | None = Form(None),
settings: str | None = Form(None),
tweaks: str | None = Form(None),
replace_duplicates: str = Form("true"),
create_filter: str = Form("false"),
document_service=Depends(get_document_service),
langflow_file_service=Depends(get_langflow_file_service),
session_manager=Depends(get_session_manager),
task_service=Depends(get_task_service),
user: User = Depends(require_api_key_permission("knowledge:upload")),
rbac=Depends(get_rbac_service),
):
"""
Ingest a document into the knowledge base.
POST /v1/documents/ingest
Request: multipart/form-data with "file" field
NOTE: `create_filter` is upload-router/onboarding metadata. The router
echoes it in the upload response so onboarding can create a saved knowledge
filter after ingestion completes. It does not affect task creation or
ingestion behavior, and the v1 SDK does not expose this option.
"""
return await upload_ingest_router(
request=request,
file=file,
session_id=session_id,
settings_json=settings,
tweaks_json=tweaks,
replace_duplicates=replace_duplicates,
create_filter=create_filter,
# Preview ingest is a frontend-only feature; the v1 SDK does not expose
# it. Pass an explicit value so the Form("false") default sentinel is not
# forwarded when this function is called directly (not via form parsing).
preview="false",
document_service=document_service,
langflow_file_service=langflow_file_service,
session_manager=session_manager,
task_service=task_service,
user=user,
rbac=rbac,
)
async def all_tasks_enhanced_endpoint(
task_service=Depends(get_task_service),
user: User = Depends(require_api_key_permission("knowledge:read:own")),
):
"""Get all ingestion tasks with structured failure metadata on failed files.
GET /v1/tasks/enhanced
Returns the same list as GET /v1/tasks/{task_id} would across all tasks,
with component, failure_phase, user_facing_message, and actionable_by
added to any failed file entry whose cause can be classified.
Note: completed files are omitted from each task's ``files`` dict to
reduce payload size; use GET /v1/tasks/{task_id}/enhanced for the full
file list of a specific task.
"""
tasks = task_service.get_all_tasks2(user.user_id)
return JSONResponse({"tasks": tasks})
async def task_status_endpoint(
task_id: str,
task_service=Depends(get_task_service),
user: User = Depends(require_api_key_permission("knowledge:read:own")),
):
"""Get the status of an ingestion task. GET /v1/tasks/{task_id}"""
task_status = task_service.get_task_status(user.user_id, task_id)
if not task_status:
return JSONResponse({"error": "Task not found"}, status_code=404)
return JSONResponse(task_status)
async def task_status_enhanced_endpoint(
task_id: str,
task_service=Depends(get_task_service),
user: User = Depends(require_api_key_permission("knowledge:read:own")),
):
"""Get the status of an ingestion task with structured failure metadata.
GET /v1/tasks/{task_id}/enhanced
Returns the same baseline task and file status information as
GET /v1/tasks/{task_id}, and additionally includes component,
failure_phase, user_facing_message, and actionable_by on any file
entry whose status is 'failed' and whose failure cause can be
classified.
Note: unlike GET /v1/tasks/enhanced, this endpoint includes completed
files in the task's ``files`` dict.
"""
task_status = task_service.get_task_status2(user.user_id, task_id)
if not task_status:
return JSONResponse({"error": "Task not found"}, status_code=404)
return JSONResponse(task_status)
async def delete_document_endpoint(
body: DeleteDocV1Body,
request: Request,
session_manager=Depends(get_session_manager),
rbac=Depends(get_rbac_service),
user: User = Depends(require_document_delete_permission),
knowledge_filter_service=Depends(get_knowledge_filter_service),
):
"""Delete document(s) from the knowledge base. DELETE /v1/documents
Provide exactly one of:
- `filename`: delete all chunks for that filename.
- `filter_id`: resolve the filter's `data_sources` and delete chunks for
each concrete filename. Empty `data_sources` or a list containing the
wildcard value `"*"` is rejected to prevent mass deletion.
"""
if bool(body.filename) == bool(body.filter_id):
return JSONResponse(
{"error": "Provide exactly one of `filename` or `filter_id`"},
status_code=400,
)
can_delete_own = await has_effective_permission(
request,
user,
rbac,
"knowledge:delete:own",
)
can_delete_anonymous = await has_effective_permission(
request,
user,
rbac,
"knowledge:delete:anonymous",
)
if body.filter_id:
resolved = await resolve_filter_id(
body.filter_id,
knowledge_filter_service,
user_id=user.user_id,
jwt_token=user.jwt_token,
)
filenames = resolved["filters"].get("data_sources") or []
if not filenames:
return JSONResponse(
{"error": "Filter has no specific data_sources to delete"},
status_code=400,
)
results = []
total_deleted = 0
statuses = []
for fname in filenames:
payload, _status = await delete_documents_by_filename_core(
filename=fname,
session_manager=session_manager,
user_id=user.user_id,
jwt_token=user.jwt_token,
can_delete_own=can_delete_own,
can_delete_anonymous=can_delete_anonymous,
)
results.append(payload)
statuses.append(_status)
total_deleted += payload.get("deleted_chunks", 0) or 0
all_ok = all(200 <= status < 300 for status in statuses)
response_status = 200 if all_ok else max(statuses)
return JSONResponse(
{
"success": all_ok,
"deleted_chunks": total_deleted,
"filenames": filenames,
"filter_id": body.filter_id,
"per_file": results,
},
status_code=response_status,
)
payload, status_code = await delete_documents_by_filename_core(
filename=body.filename,
session_manager=session_manager,
user_id=user.user_id,
jwt_token=user.jwt_token,
can_delete_own=can_delete_own,
can_delete_anonymous=can_delete_anonymous,
)
return JSONResponse(payload, status_code=status_code)