agno 2.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/os/routers/evals/utils.py

@@ -1,10 +1,11 @@
-from typing import Optional
+from typing import Optional, Union
 
 from fastapi import HTTPException
 
 from agno.agent.agent import Agent
-from agno.db.base import BaseDb
+from agno.db.base import AsyncBaseDb, BaseDb
 from agno.eval.accuracy import AccuracyEval
+from agno.eval.agent_as_judge import AgentAsJudgeEval
 from agno.eval.performance import PerformanceEval
 from agno.eval.reliability import ReliabilityEval
 from agno.models.base import Model
@@ -14,7 +15,7 @@ from agno.team.team import Team
 
 async def run_accuracy_eval(
     eval_run_input: EvalRunInput,
-    db: BaseDb,
+    db: Union[BaseDb, AsyncBaseDb],
     agent: Optional[Agent] = None,
     team: Optional[Team] = None,
     default_model: Optional[Model] = None,
@@ -33,6 +34,7 @@ async def run_accuracy_eval(
         additional_context=eval_run_input.additional_context,
         num_iterations=eval_run_input.num_iterations or 1,
         name=eval_run_input.name,
+        model=default_model,
     )
 
     result = await accuracy_eval.arun(print_results=False, print_summary=False)
@@ -41,6 +43,71 @@ async def run_accuracy_eval(
 
     eval_run = EvalSchema.from_accuracy_eval(accuracy_eval=accuracy_eval, result=result)
 
+    # Restore original model after eval
+    if default_model is not None:
+        if agent is not None:
+            agent.model = default_model
+        elif team is not None:
+            team.model = default_model
+
+    return eval_run
+
+
+async def run_agent_as_judge_eval(
+    eval_run_input: EvalRunInput,
+    db: Union[BaseDb, AsyncBaseDb],
+    agent: Optional[Agent] = None,
+    team: Optional[Team] = None,
+    default_model: Optional[Model] = None,
+) -> EvalSchema:
+    """Run an AgentAsJudge evaluation for the given agent or team"""
+    if not eval_run_input.criteria:
+        raise HTTPException(status_code=400, detail="criteria is required for agent-as-judge evaluation")
+
+    # Run agent/team to get output
+    if agent:
+        agent_response = await agent.arun(eval_run_input.input, stream=False)
+        output = str(agent_response.content) if agent_response.content else ""
+        model_id = agent.model.id if agent and agent.model else None
+        model_provider = agent.model.provider if agent and agent.model else None
+        agent_id = agent.id
+        team_id = None
+    elif team:
+        team_response = await team.arun(eval_run_input.input, stream=False)
+        output = str(team_response.content) if team_response.content else ""
+        model_id = team.model.id if team and team.model else None
+        model_provider = team.model.provider if team and team.model else None
+        agent_id = None
+        team_id = team.id
+    else:
+        raise HTTPException(status_code=400, detail="Either agent_id or team_id must be provided")
+
+    agent_as_judge_eval = AgentAsJudgeEval(
+        db=db,
+        criteria=eval_run_input.criteria,
+        scoring_strategy=eval_run_input.scoring_strategy or "binary",
+        threshold=eval_run_input.threshold or 7,
+        additional_guidelines=eval_run_input.additional_guidelines,
+        name=eval_run_input.name,
+        model=default_model,
+    )
+
+    result = await agent_as_judge_eval.arun(
+        input=eval_run_input.input, output=output, print_results=False, print_summary=False
+    )
+    if not result:
+        raise HTTPException(status_code=500, detail="Failed to run agent as judge evaluation")
+
+    eval_run = EvalSchema.from_agent_as_judge_eval(
+        agent_as_judge_eval=agent_as_judge_eval,
+        result=result,
+        agent_id=agent_id,
+        team_id=team_id,
+        model_id=model_id,
+        model_provider=model_provider,
+    )
+
+    # Restore original model after eval
     if default_model is not None:
         if agent is not None:
             agent.model = default_model
@@ -52,7 +119,7 @@ async def run_accuracy_eval(
 
 async def run_performance_eval(
     eval_run_input: EvalRunInput,
-    db: BaseDb,
+    db: Union[BaseDb, AsyncBaseDb],
     agent: Optional[Agent] = None,
     team: Optional[Team] = None,
     default_model: Optional[Model] = None,
@@ -61,15 +128,15 @@ async def run_performance_eval(
     if agent:
 
         async def run_component():  # type: ignore
-            return await agent.arun(eval_run_input.input)
+            return await agent.arun(eval_run_input.input, stream=False)
 
         model_id = agent.model.id if agent and agent.model else None
         model_provider = agent.model.provider if agent and agent.model else None
 
     elif team:
 
-        async def run_component():
-            return await team.arun(eval_run_input.input)
+        async def run_component():  # type: ignore
+            return await team.arun(eval_run_input.input, stream=False)
 
         model_id = team.model.id if team and team.model else None
         model_provider = team.model.provider if team and team.model else None
@@ -85,6 +152,7 @@ async def run_performance_eval(
         model_id=model_id,
         model_provider=model_provider,
     )
+
     result = await performance_eval.arun(print_results=False, print_summary=False)
     if not result:
         raise HTTPException(status_code=500, detail="Failed to run performance evaluation")
@@ -98,6 +166,7 @@ async def run_performance_eval(
         model_provider=model_provider,
     )
 
+    # Restore original model after eval
     if default_model is not None:
         if agent is not None:
             agent.model = default_model
@@ -109,7 +178,7 @@ async def run_performance_eval(
 
 async def run_reliability_eval(
     eval_run_input: EvalRunInput,
-    db: BaseDb,
+    db: Union[BaseDb, AsyncBaseDb],
     agent: Optional[Agent] = None,
     team: Optional[Team] = None,
     default_model: Optional[Model] = None,
@@ -119,7 +188,7 @@ async def run_reliability_eval(
         raise HTTPException(status_code=400, detail="expected_tool_calls is required for reliability evaluations")
 
     if agent:
-        agent_response = await agent.arun(eval_run_input.input)
+        agent_response = await agent.arun(eval_run_input.input, stream=False)
         reliability_eval = ReliabilityEval(
             db=db,
             name=eval_run_input.name,
@@ -130,7 +199,7 @@ async def run_reliability_eval(
         model_provider = agent.model.provider if agent and agent.model else None
 
     elif team:
-        team_response = await team.arun(eval_run_input.input)
+        team_response = await team.arun(eval_run_input.input, stream=False)
         reliability_eval = ReliabilityEval(
             db=db,
             name=eval_run_input.name,
@@ -152,6 +221,7 @@ async def run_reliability_eval(
         model_provider=model_provider,
     )
 
+    # Restore original model after eval
     if default_model is not None:
         if agent is not None:
             agent.model = default_model

agno/os/routers/health.py

@@ -1,13 +1,17 @@
+from datetime import datetime, timezone
+
 from fastapi import APIRouter
 
 from agno.os.schema import HealthResponse
 
 
-def get_health_router() -> APIRouter:
+def get_health_router(health_endpoint: str = "/health") -> APIRouter:
     router = APIRouter(tags=["Health"])
 
+    started_time_stamp = datetime.now(timezone.utc).timestamp()
+
     @router.get(
-        "/health",
+        health_endpoint,
         operation_id="health_check",
         summary="Health Check",
         description="Check the health status of the AgentOS API. Returns a simple status indicator.",
@@ -15,11 +19,13 @@ def get_health_router() -> APIRouter:
         responses={
             200: {
                 "description": "API is healthy and operational",
-                "content": {"application/json": {"example": {"status": "ok"}}},
+                "content": {
+                    "application/json": {"example": {"status": "ok", "instantiated_at": str(started_time_stamp)}}
+                },
             }
         },
     )
     async def health_check() -> HealthResponse:
-        return HealthResponse(status="ok")
+        return HealthResponse(status="ok", instantiated_at=str(started_time_stamp))
 
     return router

agno/os/routers/knowledge/knowledge.py

@@ -1,7 +1,7 @@
 import json
 import logging
 import math
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
 
 from fastapi import APIRouter, BackgroundTasks, Depends, File, Form, HTTPException, Path, Query, UploadFile
 
@@ -19,6 +19,9 @@ from agno.os.routers.knowledge.schemas import (
     ContentStatusResponse,
     ContentUpdateSchema,
     ReaderSchema,
+    VectorDbSchema,
+    VectorSearchRequestSchema,
+    VectorSearchResult,
 )
 from agno.os.schema import (
     BadRequestResponse,
@@ -99,6 +102,8 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         text_content: Optional[str] = Form(None, description="Raw text content to process"),
         reader_id: Optional[str] = Form(None, description="ID of the reader to use for content processing"),
         chunker: Optional[str] = Form(None, description="Chunking strategy to apply during processing"),
+        chunk_size: Optional[int] = Form(None, description="Chunk size to use for processing"),
+        chunk_overlap: Optional[int] = Form(None, description="Chunk overlap to use for processing"),
         db_id: Optional[str] = Query(default=None, description="Database ID to use for content storage"),
     ):
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
@@ -169,7 +174,7 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         content.content_hash = content_hash
         content.id = generate_id(content_hash)
 
-        background_tasks.add_task(process_content, knowledge, content, reader_id, chunker)
+        background_tasks.add_task(process_content, knowledge, content, reader_id, chunker, chunk_size, chunk_overlap)
 
         response = ContentResponseSchema(
             id=content.id,
@@ -303,7 +308,7 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             }
         },
     )
-    def get_content(
+    async def get_content(
         limit: Optional[int] = Query(default=20, description="Number of content entries to return"),
         page: Optional[int] = Query(default=1, description="Page number"),
         sort_by: Optional[str] = Query(default="created_at", description="Field to sort by"),
@@ -311,7 +316,7 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
     ) -> PaginatedResponse[ContentResponseSchema]:
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
-        contents, count = knowledge.get_content(limit=limit, page=page, sort_by=sort_by, sort_order=sort_order)
+        contents, count = await knowledge.aget_content(limit=limit, page=page, sort_by=sort_by, sort_order=sort_order)
 
         return PaginatedResponse(
             data=[
@@ -371,13 +376,13 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             404: {"description": "Content not found", "model": NotFoundResponse},
         },
     )
-    def get_content_by_id(
+    async def get_content_by_id(
         content_id: str,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
     ) -> ContentResponseSchema:
         log_info(f"Getting content by id: {content_id}")
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
-        content = knowledge.get_content_by_id(content_id=content_id)
+        content = await knowledge.aget_content_by_id(content_id=content_id)
         if not content:
             raise HTTPException(status_code=404, detail=f"Content not found: {content_id}")
         response = ContentResponseSchema.from_dict(
@@ -411,12 +416,12 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             500: {"description": "Failed to delete content", "model": InternalServerErrorResponse},
         },
     )
-    def delete_content_by_id(
+    async def delete_content_by_id(
         content_id: str,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
     ) -> ContentResponseSchema:
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
-        knowledge.remove_content_by_id(content_id=content_id)
+        await knowledge.aremove_content_by_id(content_id=content_id)
         log_info(f"Deleting content by id: {content_id}")
 
         return ContentResponseSchema(
@@ -443,7 +448,6 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
         log_info("Deleting all content")
         knowledge.remove_all_content()
-
         return "success"
 
     @router.get(
@@ -476,13 +480,13 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             404: {"description": "Content not found", "model": NotFoundResponse},
         },
     )
-    def get_content_status(
+    async def get_content_status(
         content_id: str,
         db_id: Optional[str] = Query(default=None, description="The ID of the database to use"),
     ) -> ContentStatusResponse:
         log_info(f"Getting content status: {content_id}")
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
-        knowledge_status, status_message = knowledge.get_content_status(content_id=content_id)
+        knowledge_status, status_message = await knowledge.aget_content_status(content_id=content_id)
 
         # Handle the case where content is not found
         if knowledge_status is None:
@@ -513,11 +517,107 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
 
         return ContentStatusResponse(status=status, status_message=status_message or "")
 
+    @router.post(
+        "/knowledge/search",
+        status_code=200,
+        operation_id="search_knowledge",
+        summary="Search Knowledge",
+        description="Search the knowledge base for relevant documents using query, filters and search type.",
+        response_model=PaginatedResponse[VectorSearchResult],
+        responses={
+            200: {
+                "description": "Search results retrieved successfully",
+                "content": {
+                    "application/json": {
+                        "example": {
+                            "data": [
+                                {
+                                    "id": "doc_123",
+                                    "content": "Jordan Mitchell - Software Engineer with skills in JavaScript, React, Python",
+                                    "name": "cv_1",
+                                    "meta_data": {"page": 1, "chunk": 1},
+                                    "usage": {"total_tokens": 14},
+                                    "reranking_score": 0.95,
+                                    "content_id": "content_456",
+                                }
+                            ],
+                            "meta": {"page": 1, "limit": 20, "total_pages": 2, "total_count": 35},
+                        }
+                    }
+                },
+            },
+            400: {"description": "Invalid search parameters"},
+            404: {"description": "No documents found"},
+        },
+    )
+    def search_knowledge(request: VectorSearchRequestSchema) -> PaginatedResponse[VectorSearchResult]:
+        import time
+
+        start_time = time.time()
+
+        knowledge = get_knowledge_instance_by_db_id(knowledge_instances, request.db_id)
+
+        # For now, validate the vector db ids exist in the knowledge base
+        # We will add more logic around this once we have multi vectordb support
+        # If vector db ids are provided, check if any of them match the knowledge's vector db
+        if request.vector_db_ids:
+            if knowledge.vector_db and knowledge.vector_db.id:
+                if knowledge.vector_db.id not in request.vector_db_ids:
+                    raise HTTPException(
+                        status_code=400,
+                        detail=f"None of the provided Vector DB IDs {request.vector_db_ids} match the knowledge base Vector DB ID {knowledge.vector_db.id}",
+                    )
+            else:
+                raise HTTPException(status_code=400, detail="Knowledge base has no vector database configured")
+
+        # Calculate pagination parameters
+        meta = request.meta
+        limit = meta.limit if meta and meta.limit is not None else 20
+        page = meta.page if meta and meta.page is not None else 1
+
+        # Use max_results if specified, otherwise use a higher limit for search then paginate
+        search_limit = request.max_results
+
+        results = knowledge.search(
+            query=request.query, max_results=search_limit, filters=request.filters, search_type=request.search_type
+        )
+
+        # Calculate pagination
+        total_results = len(results)
+        start_idx = (page - 1) * limit
+
+        # Ensure start_idx doesn't exceed the total results
+        if start_idx >= total_results and total_results > 0:
+            # If page is beyond available results, return empty results
+            paginated_results = []
+        else:
+            end_idx = min(start_idx + limit, total_results)
+            paginated_results = results[start_idx:end_idx]
+
+        search_time_ms = (time.time() - start_time) * 1000
+
+        # Convert Document objects to serializable format
+        document_results = [VectorSearchResult.from_document(doc) for doc in paginated_results]
+
+        # Calculate pagination info
+        total_pages = (total_results + limit - 1) // limit  # Ceiling division
+
+        return PaginatedResponse(
+            data=document_results,
+            meta=PaginationInfo(
+                page=page,
+                limit=limit,
+                total_pages=total_pages,
+                total_count=total_results,
+                search_time_ms=search_time_ms,
+            ),
+        )
+
     @router.get(
         "/knowledge/config",
         status_code=200,
         operation_id="get_knowledge_config",
-        summary="Get Knowledge Configuration",
+        summary="Get Config",
         description=(
             "Retrieve available readers, chunkers, and configuration options for content processing. "
             "This endpoint provides metadata about supported file types, processing strategies, and filters."
@@ -703,38 +803,65 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
                                     "key": "AgenticChunker",
                                     "name": "AgenticChunker",
                                     "description": "Chunking strategy that uses an LLM to determine natural breakpoints in the text",
+                                    "metadata": {"chunk_size": 5000},
                                 },
                                 "DocumentChunker": {
                                     "key": "DocumentChunker",
                                     "name": "DocumentChunker",
                                     "description": "A chunking strategy that splits text based on document structure like paragraphs and sections",
-                                },
-                                "RecursiveChunker": {
-                                    "key": "RecursiveChunker",
-                                    "name": "RecursiveChunker",
-                                    "description": "Chunking strategy that recursively splits text into chunks by finding natural break points",
-                                },
-                                "SemanticChunker": {
-                                    "key": "SemanticChunker",
-                                    "name": "SemanticChunker",
-                                    "description": "Chunking strategy that splits text into semantic chunks using chonkie",
+                                    "metadata": {
+                                        "chunk_size": 5000,
+                                        "chunk_overlap": 0,
+                                    },
                                 },
                                 "FixedSizeChunker": {
                                     "key": "FixedSizeChunker",
                                     "name": "FixedSizeChunker",
                                     "description": "Chunking strategy that splits text into fixed-size chunks with optional overlap",
+                                    "metadata": {
+                                        "chunk_size": 5000,
+                                        "chunk_overlap": 0,
+                                    },
+                                },
+                                "MarkdownChunker": {
+                                    "key": "MarkdownChunker",
+                                    "name": "MarkdownChunker",
+                                    "description": "A chunking strategy that splits markdown based on structure like headers, paragraphs and sections",
+                                    "metadata": {
+                                        "chunk_size": 5000,
+                                        "chunk_overlap": 0,
+                                    },
+                                },
+                                "RecursiveChunker": {
+                                    "key": "RecursiveChunker",
+                                    "name": "RecursiveChunker",
+                                    "description": "Chunking strategy that recursively splits text into chunks by finding natural break points",
+                                    "metadata": {
+                                        "chunk_size": 5000,
+                                        "chunk_overlap": 0,
+                                    },
                                 },
                                 "RowChunker": {
                                     "key": "RowChunker",
                                     "name": "RowChunker",
                                     "description": "RowChunking chunking strategy",
+                                    "metadata": {},
                                 },
-                                "MarkdownChunker": {
-                                    "key": "MarkdownChunker",
-                                    "name": "MarkdownChunker",
-                                    "description": "A chunking strategy that splits markdown based on structure like headers, paragraphs and sections",
+                                "SemanticChunker": {
+                                    "key": "SemanticChunker",
+                                    "name": "SemanticChunker",
+                                    "description": "Chunking strategy that splits text into semantic chunks using chonkie",
+                                    "metadata": {"chunk_size": 5000},
                                 },
                             },
+                            "vector_dbs": [
+                                {
+                                    "id": "vector_db_1",
+                                    "name": "Vector DB 1",
+                                    "description": "Vector DB 1 description",
+                                    "search_types": ["vector", "keyword", "hybrid"],
+                                }
+                            ],
                             "filters": ["filter_tag_1", "filter_tag2"],
                         }
                     }
@@ -747,8 +874,8 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
     ) -> ConfigResponseSchema:
         knowledge = get_knowledge_instance_by_db_id(knowledge_instances, db_id)
 
-        # Get factory readers info
-        readers_info = get_all_readers_info()
+        # Get factory readers info (including custom readers from this knowledge instance)
+        readers_info = get_all_readers_info(knowledge)
         reader_schemas = {}
         # Add factory readers
         for reader_info in readers_info:
@@ -760,7 +887,12 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             )
 
         # Add custom readers from knowledge.readers
-        readers_dict: Dict[str, Reader] = knowledge.get_readers() or {}
+        readers_result: Any = knowledge.get_readers() or {}
+        # Ensure readers_dict is a dictionary (defensive check)
+        if not isinstance(readers_result, dict):
+            readers_dict: Dict[str, Reader] = {}
+        else:
+            readers_dict = readers_result
         if readers_dict:
             for reader_id, reader in readers_dict.items():
                 # Get chunking strategies from the reader
@@ -780,8 +912,8 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
                         chunkers=chunking_strategies,
                     )
 
-        # Get content types to readers mapping
-        types_of_readers = get_content_types_to_readers_mapping()
+        # Get content types to readers mapping (including custom readers from this knowledge instance)
+        types_of_readers = get_content_types_to_readers_mapping(knowledge)
         chunkers_list = get_all_chunkers_info()
 
         # Convert chunkers list to dictionary format expected by schema
@@ -790,14 +922,32 @@ def attach_routes(router: APIRouter, knowledge_instances: List[Knowledge]) -> AP
             chunker_key = chunker_info.get("key")
             if chunker_key:
                 chunkers_dict[chunker_key] = ChunkerSchema(
-                    key=chunker_key, name=chunker_info.get("name"), description=chunker_info.get("description")
+                    key=chunker_key,
+                    name=chunker_info.get("name"),
+                    description=chunker_info.get("description"),
+                    metadata=chunker_info.get("metadata", {}),
                 )
 
+        vector_dbs = []
+        if knowledge.vector_db:
+            search_types = knowledge.vector_db.get_supported_search_types()
+            name = knowledge.vector_db.name
+            db_id = knowledge.vector_db.id
+            vector_dbs.append(
+                VectorDbSchema(
+                    id=db_id,
+                    name=name,
+                    description=knowledge.vector_db.description,
+                    search_types=search_types,
+                )
+            )
+
         return ConfigResponseSchema(
             readers=reader_schemas,
+            vector_dbs=vector_dbs,
             readersForType=types_of_readers,
             chunkers=chunkers_dict,
-            filters=knowledge.get_filters(),
+            filters=knowledge.get_valid_filters(),
         )
 
     return router
@@ -808,33 +958,41 @@ async def process_content(
     content: Content,
     reader_id: Optional[str] = None,
     chunker: Optional[str] = None,
+    chunk_size: Optional[int] = None,
+    chunk_overlap: Optional[int] = None,
 ):
     """Background task to process the content"""
 
     try:
         if reader_id:
             reader = None
-            if knowledge.readers and reader_id in knowledge.readers:
-                reader = knowledge.readers[reader_id]
+            # Use get_readers() to ensure we get a dict (handles list conversion)
+            custom_readers = knowledge.get_readers()
+            if custom_readers and reader_id in custom_readers:
+                reader = custom_readers[reader_id]
+                log_debug(f"Found custom reader: {reader.__class__.__name__}")
             else:
+                # Try to resolve from factory readers
                 key = reader_id.lower().strip().replace("-", "_").replace(" ", "_")
                 candidates = [key] + ([key[:-6]] if key.endswith("reader") else [])
                 for cand in candidates:
                     try:
                         reader = ReaderFactory.create_reader(cand)
-                        log_debug(f"Resolved reader: {reader.__class__.__name__}")
+                        log_debug(f"Resolved reader from factory: {reader.__class__.__name__}")
                         break
                     except Exception:
                         continue
             if reader:
                 content.reader = reader
+            else:
+                log_debug(f"Could not resolve reader with id: {reader_id}")
         if chunker and content.reader:
             # Set the chunker name on the reader - let the reader handle it internally
-            content.reader.set_chunking_strategy_from_string(chunker)
+            content.reader.set_chunking_strategy_from_string(chunker, chunk_size=chunk_size, overlap=chunk_overlap)
             log_debug(f"Set chunking strategy: {chunker}")
 
         log_debug(f"Using reader: {content.reader.__class__.__name__}")
-        await knowledge._load_content(content, upsert=False, skip_if_exists=True)
+        await knowledge._load_content_async(content, upsert=False, skip_if_exists=True)
         log_info(f"Content {content.id} processed successfully")
     except Exception as e:
         log_info(f"Error processing content: {e}")