~95% on SimpleQA (e.g. Qwen3.6-27B on a 3090). Supports all local and cloud LLMs (llama.cpp, Ollama, Google, ...). 10+ search engines - arXiv, PubMed, your private documents. Everything Local & Encrypted.
Python academiaanthropicarxivbravedeep-researchencryptionhome-automationhomeserverlocallocal-deep-researchlocal-llmmistralollamaopenaipubmedresearchresearch-toolretrieval-augmented-generationsearxngself-hosted
from collections.abc import Collection
from dataclasses import dataclass
from datetime import UTC, datetime
from sqlalchemy import exists
from sqlalchemy.orm import Session
from ...database.models import QueuedResearch, QueueStatus, TaskMetadata
@dataclass(frozen=True, slots=True)
class QueuedResearchCleanupResult:
"""Cleaned and protected IDs can overlap for legacy shared queue IDs."""
cleaned_ids: frozenset[str]
protected_ids: frozenset[str]
def reconcile_research_queue_status(
db_session: Session, *, force: bool = False
) -> bool:
"""Recompute research capacity counters without committing the transaction."""
queued_tasks = (
db_session.query(TaskMetadata)
.filter_by(task_type="research", status="queued")
.count()
)
active_tasks = (
db_session.query(TaskMetadata)
.filter_by(task_type="research", status="processing")
.count()
)
queue_status = db_session.query(QueueStatus).first()
if queue_status is None:
db_session.add(
QueueStatus(
active_tasks=active_tasks,
queued_tasks=queued_tasks,
last_checked=datetime.now(UTC),
)
)
return True
changed = (
queue_status.active_tasks != active_tasks
or queue_status.queued_tasks != queued_tasks
)
if changed or force:
queue_status.active_tasks = active_tasks
queue_status.queued_tasks = queued_tasks
queue_status.last_checked = datetime.now(UTC)
return changed or force
def cleanup_queued_research_state(
db_session: Session,
research_ids: Collection[str],
include_claimed: bool = False,
acting_user: str | None = None,
) -> QueuedResearchCleanupResult:
"""Remove queued research state while leaving transaction control to the caller.
With ``acting_user``, a queue row another user owns is left in place, and so
is the task metadata of its research ID, which that row still needs. Such
IDs are reported as protected. ``TaskMetadata`` has no owner column, so
metadata that no queue row points at is removed either way.
"""
research_id_set = set(research_ids)
if not research_id_set:
return QueuedResearchCleanupResult(frozenset(), frozenset())
claimed_ids: set[str] = set()
if not include_claimed:
claimed_ids = {
research_id
for (research_id,) in (
db_session.query(QueuedResearch.research_id)
.filter(
QueuedResearch.research_id.in_(research_id_set),
QueuedResearch.is_processing.is_(True),
)
.all()
)
}
cleanup_ids = research_id_set - claimed_ids
if not cleanup_ids:
return QueuedResearchCleanupResult(frozenset(), frozenset(claimed_ids))
queued_rows = (
db_session.query(QueuedResearch)
.filter(QueuedResearch.research_id.in_(cleanup_ids))
.all()
)
foreign_ids: set[str] = set()
if acting_user is not None:
foreign_ids = {
queued_row.research_id
for queued_row in queued_rows
if queued_row.username != acting_user
}
queued_rows = [
queued_row
for queued_row in queued_rows
if queued_row.username == acting_user
]
usernames = {queued_row.username for queued_row in queued_rows}
for queued_row in queued_rows:
db_session.delete(queued_row)
metadata_ids = cleanup_ids - foreign_ids
if metadata_ids:
metadata_query = db_session.query(TaskMetadata).filter(
TaskMetadata.task_id.in_(metadata_ids),
TaskMetadata.task_type == "research",
)
if acting_user is not None:
# Ownership must still hold when DELETE executes, not just when
# queued_rows was loaded. A foreign row may have committed since.
metadata_query = metadata_query.filter(
~exists().where(
QueuedResearch.research_id == TaskMetadata.task_id,
QueuedResearch.username != acting_user,
)
)
metadata_query.delete(synchronize_session=False)
if acting_user is not None:
current_foreign_ids = {
research_id
for (research_id,) in db_session.query(QueuedResearch.research_id)
.filter(
QueuedResearch.research_id.in_(cleanup_ids),
QueuedResearch.username != acting_user,
)
.all()
}
late_foreign_ids = current_foreign_ids - foreign_ids
# Preserve existing result semantics for preloaded shared IDs. Only
# reconcile the newly protected IDs: own rows were still removed,
# whereas foreign-only IDs had no state cleaned.
metadata_ids -= late_foreign_ids - {
row.research_id for row in queued_rows
}
foreign_ids |= current_foreign_ids
for username in usernames:
surviving_rows = (
db_session.query(QueuedResearch)
.filter_by(username=username)
.order_by(QueuedResearch.position, QueuedResearch.id)
.all()
)
for position, queued_row in enumerate(surviving_rows, start=1):
queued_row.position = position
reconcile_research_queue_status(db_session, force=True)
return QueuedResearchCleanupResult(
frozenset(metadata_ids | {row.research_id for row in queued_rows}),
frozenset(claimed_ids | foreign_ids),
)