Knowledge SDK Reference - Orq.ai Documentation

Knowledge

List Knowledge

Returns a list of your knowledge bases. The knowledge bases are returned sorted by creation date, with the most recent knowledge bases appearing first

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.knowledge.list(limit=300)

    # Handle response
    print(res)

Show Parameters

{
    "starting_after": Optional[str],
    "ending_before": Optional[str],
    "limit": Optional[float],
}

Show Response

{
    "object": Literal["list"],
    "data": Union[Data1, Data2],
    "has_more": bool,
}

Create a Knowledge

Create a knowledge

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.knowledge.create(request={
        "type": "internal",
        "key": "<key>",
        "embedding_model": "<value>",
        "path": "Default",
    })

    # Handle response
    print(res)

Show Parameters

{
    "type": Optional[Literal["internal"]],
    "key": str,  # required
    "description": Optional[str],
    "embedding_model": str,  # required
    "retrieval_settings": {  # optional
        "retrieval_type": Optional[Literal["vector_search", "keyword_search", "hybrid_search"]],
        "top_k": Optional[int],
        "threshold": Optional[float],
        "rerank_config": {  # optional
            "top_k": Optional[int],
            "rerank_threshold": Optional[float],
            "rerank_model": str,  # required
        },
        "agentic_rag_config": {  # optional
            "model": str,  # required
        },
    },
    "path": str,  # required
}

Show Response

{
    "id": str,
    "created": str,
    "description": OptionalNullable[str],
    "key": str,
    "domain_id": str,
    "path": Optional[str],
    "created_by_id": OptionalNullable[str],
    "updated_by_id": OptionalNullable[str],
    "updated": str,
    "type": Optional[Literal["internal"]],
    "retrieval_settings": {  # optional
        "retrieval_type": Optional[Literal["vector_search", "keyword_search", "hybrid_search"]],
        "top_k": Optional[int],
        "threshold": Optional[float],
        "rerank_config": {  # optional
            "top_k": Optional[int],
            "rerank_threshold": Optional[float],
            "rerank_model": str,
        },
        "agentic_rag_config": {  # optional
            "model": str,
        },
    },
    "model": str,
}

Retrieve a Knowledge

Retrieve a knowledge base with the settings.

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.knowledge.retrieve(knowledge_id="<id>")

    # Handle response
    print(res)

Show Parameters

{
    "knowledge_id": str,  # required
}

Show Response

{
    "id": str,
    "created": str,
    "description": OptionalNullable[str],
    "key": str,
    "domain_id": str,
    "path": Optional[str],
    "created_by_id": OptionalNullable[str],
    "updated_by_id": OptionalNullable[str],
    "updated": str,
    "type": Optional[Literal["internal"]],
    "retrieval_settings": {  # optional
        "retrieval_type": Optional[Literal["vector_search", "keyword_search", "hybrid_search"]],
        "top_k": Optional[int],
        "threshold": Optional[float],
        "rerank_config": {  # optional
            "top_k": Optional[int],
            "rerank_threshold": Optional[float],
            "rerank_model": str,
        },
        "agentic_rag_config": {  # optional
            "model": str,
        },
    },
    "model": str,
}

Update a Knowledge

Updates a knowledge

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.knowledge.update(knowledge_id="<id>", request_body={
        "path": "Default",
        "type": "external",
    })

    # Handle response
    print(res)

Show Parameters

{
    "knowledge_id": str,  # required
    "request_body": Union[UpdateKnowledgeRequestBody1, UpdateKnowledgeRequestBody2],  # required
}

Show Response

{
    "id": str,
    "created": str,
    "description": OptionalNullable[str],
    "key": str,
    "domain_id": str,
    "path": Optional[str],
    "created_by_id": OptionalNullable[str],
    "updated_by_id": OptionalNullable[str],
    "updated": str,
    "type": Optional[Literal["internal"]],
    "retrieval_settings": {  # optional
        "retrieval_type": Optional[Literal["vector_search", "keyword_search", "hybrid_search"]],
        "top_k": Optional[int],
        "threshold": Optional[float],
        "rerank_config": {  # optional
            "top_k": Optional[int],
            "rerank_threshold": Optional[float],
            "rerank_model": str,
        },
        "agentic_rag_config": {  # optional
            "model": str,
        },
    },
    "model": str,
}

Delete a Knowledge

Deletes a knowledge base. Deleting a knowledge base will delete all the datasources and chunks associated with it.

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    orq.knowledge.delete(knowledge_id="<id>")

    # Use the SDK ...

Show Parameters

{
    "knowledge_id": str,  # required
}

Search Knowledge

Search a Knowledge Base and return the most similar chunks, along with their search and rerank scores. Note that all configuration changes made in the API will override the settings in the UI.

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.knowledge.search(knowledge_id="<id>", query="<value>", search_type="hybrid_search", rerank_config={
        "model": "cohere/rerank-multilingual-v3.0",
    })

    # Handle response
    print(res)

Show Parameters

{
    "knowledge_id": str,  # required
    "query": str,  # required
    "top_k": Optional[int],
    "threshold": Optional[float],
    "search_type": Optional[Literal["vector_search", "keyword_search", "hybrid_search"]],
    "filter_by": Union[Dict[str, FilterBy1], FilterByAnd, FilterByOr],
    "search_options": {  # optional
        "include_vectors": Optional[bool],
        "include_metadata": Optional[bool],
        "include_scores": Optional[bool],
    },
    "rerank_config": {  # optional
        "model": str,  # required
        "threshold": Optional[float],
        "top_k": Optional[int],
    },
    "agentic_rag_config": {  # optional
        "model": str,  # required
    },
}

Show Response

{
    "matches": {
        "id": str,
        "text": str,
        "vector": List[float],
        "metadata": Dict[str, Any],
        "scores": {  # optional
            "rerank_score": Optional[float],
            "search_score": Optional[float],
        },
    },
}

List Datasources

List all datasources

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.knowledge.list_datasources(knowledge_id="<id>", limit=50, status=[
        "completed",
        "failed",
    ])

    # Handle response
    print(res)

Show Parameters

{
    "knowledge_id": str,  # required
    "starting_after": Optional[str],
    "ending_before": Optional[str],
    "q": Optional[str],
    "limit": Optional[float],
    "status": Union[List[str], str],
}

Show Response

{
    "object": Literal["list"],
    "data": {
        "id": Optional[str],
        "display_name": str,
        "description": OptionalNullable[str],
        "status": Literal["pending", "processing", "completed", "failed", "queued"],
        "file_id": OptionalNullable[str],
        "created": str,
        "updated": str,
        "created_by_id": OptionalNullable[str],
        "update_by_id": OptionalNullable[str],
        "knowledge_id": str,
        "chunks_count": float,
    },
    "has_more": bool,
}

Create Datasource

Create a new datasource

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.knowledge.create_datasource(knowledge_id="<id>")

    # Handle response
    print(res)

Show Parameters

{
    "knowledge_id": str,  # required
    "display_name": Optional[str],
    "description": OptionalNullable[str],
    "file_id": Optional[str],
    "chunking_options": {  # optional
        "chunking_configuration": Union[ChunkingConfiguration1, ChunkingConfiguration2],
        "chunking_cleanup_options": {  # optional
            "delete_emails": Optional[bool],
            "delete_credit_cards": Optional[bool],
            "delete_phone_numbers": Optional[bool],
            "clean_bullet_points": Optional[bool],
            "clean_numbered_list": Optional[bool],
            "clean_unicode": Optional[bool],
            "clean_dashes": Optional[bool],
            "clean_whitespaces": Optional[bool],
        },
    },
}

Show Response

{
    "id": Optional[str],
    "display_name": str,
    "description": OptionalNullable[str],
    "status": Literal["pending", "processing", "completed", "failed", "queued"],
    "file_id": OptionalNullable[str],
    "created": str,
    "updated": str,
    "created_by_id": OptionalNullable[str],
    "update_by_id": OptionalNullable[str],
    "knowledge_id": str,
    "chunks_count": float,
}

Retrieve Datasource

Retrieve a datasource

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.knowledge.retrieve_datasource(knowledge_id="<id>", datasource_id="<id>")

    # Handle response
    print(res)

Show Parameters

{
    "knowledge_id": str,  # required
    "datasource_id": str,  # required
}

Show Response

{
    "id": Optional[str],
    "display_name": str,
    "description": OptionalNullable[str],
    "status": Literal["pending", "processing", "completed", "failed", "queued"],
    "file_id": OptionalNullable[str],
    "created": str,
    "updated": str,
    "created_by_id": OptionalNullable[str],
    "update_by_id": OptionalNullable[str],
    "knowledge_id": str,
    "chunks_count": float,
}

Delete Datasource

Deletes a datasource from a knowledge base. Deleting a datasource will remove it from the knowledge base and all associated chunks. This action is irreversible and cannot be undone.

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    orq.knowledge.delete_datasource(knowledge_id="<id>", datasource_id="<id>")

    # Use the SDK ...

Show Parameters

{
    "knowledge_id": str,  # required
    "datasource_id": str,  # required
}

Update Datasource

Update a datasource

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.knowledge.update_datasource(knowledge_id="<id>", datasource_id="<id>", display_name="Tony_Roberts")

    # Handle response
    print(res)

Show Parameters

{
    "knowledge_id": str,  # required
    "datasource_id": str,  # required
    "display_name": str,  # required
}

Show Response

{
    "id": Optional[str],
    "display_name": str,
    "description": OptionalNullable[str],
    "status": Literal["pending", "processing", "completed", "failed", "queued"],
    "file_id": OptionalNullable[str],
    "created": str,
    "updated": str,
    "created_by_id": OptionalNullable[str],
    "update_by_id": OptionalNullable[str],
    "knowledge_id": str,
    "chunks_count": float,
}

Create Chunks

Create chunks for a datasource

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.knowledge.create_chunks(knowledge_id="<id>", datasource_id="<id>")

    # Handle response
    print(res)

Show Parameters

{
    "knowledge_id": str,  # required
    "datasource_id": str,  # required
    "request_body": {  # optional
        "text": str,  # required
        "embedding": List[float],
        "metadata": Union[str, float, bool],
    },
}

List Chunks

List all chunks for a datasource

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.knowledge.list_chunks(knowledge_id="<id>", datasource_id="<id>", limit=10, status=[
        "completed",
        "failed",
    ])

    # Handle response
    print(res)

Show Parameters

{
    "knowledge_id": str,  # required
    "datasource_id": str,  # required
    "limit": Optional[int],
    "starting_after": Optional[str],
    "ending_before": Optional[str],
    "q": Optional[str],
    "status": Union[List[QueryParam1], QueryParam2],
}

Show Response

{
    "object": Literal["list"],
    "data": {
        "id": str,
        "text": str,
        "metadata": Union[str, float, bool],
        "enabled": bool,
        "status": Literal["pending", "processing", "completed", "failed", "queued"],
        "created": str,
        "updated": str,
        "created_by_id": OptionalNullable[str],
        "update_by_id": OptionalNullable[str],
    },
    "has_more": bool,
}

Delete Chunks

Delete multiple chunks

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.knowledge.delete_chunks(knowledge_id="<id>", datasource_id="<id>", chunk_ids=[
        "<value 1>",
        "<value 2>",
    ])

    # Handle response
    print(res)

Show Parameters

{
    "knowledge_id": str,  # required
    "datasource_id": str,  # required
    "chunk_ids": List[str],  # required
}

Show Response

{
    "deleted_count": float,
    "failed_ids": List[str],
}

List Chunks Paginated

List chunks with offset-based pagination

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.knowledge.list_chunks_paginated(knowledge_id="<id>", datasource_id="<id>", q="", limit=100, page=1)

    # Handle response
    print(res)

Show Parameters

{
    "knowledge_id": str,  # required
    "datasource_id": str,  # required
    "q": Optional[str],
    "enabled": Optional[bool],
    "status": Optional[Literal["pending", "processing", "completed", "failed", "queued"]],
    "limit": Optional[int],
    "page": Optional[int],
}

Show Response

{
    "object": Literal["list"],
    "data": {
        "id": str,
        "text": str,
        "metadata": Union[str, float, bool],
        "enabled": bool,
        "status": Literal["pending", "processing", "completed", "failed", "queued"],
        "created": str,
        "updated": str,
        "created_by_id": OptionalNullable[str],
        "update_by_id": OptionalNullable[str],
    },
    "has_more": bool,
}

Get Chunks Count

Returns the total count of chunks in a datasource. When q is provided, the count reflects indexed chunks only - recently created chunks may not be counted until embedding completes.

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.knowledge.get_chunks_count(knowledge_id="<id>", datasource_id="<id>", q="")

    # Handle response
    print(res)

Show Parameters

{
    "knowledge_id": str,  # required
    "datasource_id": str,  # required
    "q": Optional[str],
    "enabled": Optional[bool],
    "status": Optional[Literal["pending", "processing", "completed", "failed", "queued"]],
}

Show Response

{
    "count": float,
}

Update Chunk

Update a chunk

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.knowledge.update_chunk(chunk_id="<id>", datasource_id="<id>", knowledge_id="<id>")

    # Handle response
    print(res)

Show Parameters

{
    "chunk_id": str,  # required
    "datasource_id": str,  # required
    "knowledge_id": str,  # required
    "text": Optional[str],
    "embedding": List[float],
    "metadata": Union[str, float, bool],
}

Show Response

{
    "id": str,
    "text": str,
    "metadata": Union[str, float, bool],
    "enabled": bool,
    "status": Literal["pending", "processing", "completed", "failed", "queued"],
    "created": str,
    "updated": str,
    "created_by_id": OptionalNullable[str],
    "update_by_id": OptionalNullable[str],
}

Delete Chunk

Delete a chunk

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    orq.knowledge.delete_chunk(chunk_id="<id>", datasource_id="<id>", knowledge_id="<id>")

    # Use the SDK ...

Show Parameters

{
    "chunk_id": str,  # required
    "datasource_id": str,  # required
    "knowledge_id": str,  # required
}

Retrieve Chunk

Retrieve a chunk

from orq_ai_sdk import Orq
import os

with Orq(
    api_key=os.getenv("ORQ_API_KEY", ""),
) as orq:

    res = orq.knowledge.retrieve_chunk(chunk_id="<id>", datasource_id="<id>", knowledge_id="<id>")

    # Handle response
    print(res)

Show Parameters

{
    "chunk_id": str,  # required
    "datasource_id": str,  # required
    "knowledge_id": str,  # required
}

Show Response

{
    "id": str,
    "text": str,
    "metadata": Union[str, float, bool],
    "enabled": bool,
    "status": Literal["pending", "processing", "completed", "failed", "queued"],
    "created": str,
    "updated": str,
    "created_by_id": OptionalNullable[str],
    "update_by_id": OptionalNullable[str],
}

​Knowledge

​List Knowledge

​Create a Knowledge

​Retrieve a Knowledge

​Update a Knowledge

​Delete a Knowledge

​Search Knowledge

​List Datasources

​Create Datasource

​Retrieve Datasource

​Delete Datasource

​Update Datasource

​Create Chunks

​List Chunks

​Delete Chunks

​List Chunks Paginated

​Get Chunks Count

​Update Chunk

​Delete Chunk

​Retrieve Chunk

Knowledge

List Knowledge

Create a Knowledge

Retrieve a Knowledge

Update a Knowledge

Delete a Knowledge

Search Knowledge

List Datasources

Create Datasource

Retrieve Datasource

Delete Datasource

Update Datasource

Create Chunks

List Chunks

Delete Chunks

List Chunks Paginated

Get Chunks Count

Update Chunk

Delete Chunk

Retrieve Chunk