Delete all resources associated with a given cloud application.

Args:
    app_name: Name of the application whose data should be removed.
    auth: Authentication context of the requesting user.

Returns:
    A summary describing how many documents and folders were removed.

Delete Cloud App

Location

Message

Error Type

ValidationError

Response Delete Cloud App Cloud Apps Delete

HTTPValidationError

Morphik Documentation

What is Morphik?

Getting Started

Get the most out of Morphik by customizing it to your needs

Configure Morphik

An overview of Retrieval Augmented Generation with Vector Similarity Search

Introduction to RAG

Intelligent agentic query processing with autonomous tool usage

Morphik Agent

Organizing data with user and folder scoping in Morphik

User and Folder Scoping

An overview of rules based ingestion in Morphik

Rules

Using Late-interaction and Contrastive learning to achieve state-of-the-art performance in visual retrieval

Retrieving Images

Leveraging graph-based relationships for improved context and retrieval in RAG systems

Knowledge Graphs and Graph RAG

Learn how to use the Morphik UI interface

Morphik UI

Learn how to use the Morphik command-line interface

Morphik Shell

Enable Claude and other AI assistants to access your Morphik knowledge base

Model Context Protocol (MCP)

Learn how to use the Morphik Python SDK or REST API

Code

Practical examples of using the Morphik Agent for complex analysis tasks

Agent Workflows

Learn how to provision and manage isolated Morphik application environments.

Morphik Management API

Thanking our amazing users for pointing out bugs, requesting features, and being early adopters ❤️

Special Thanks

What I Learnt From Vibe-Coding an Open-Source Alternative to ChatGPT's New Memory Feature

Vibe-Coding Memory

Drowning in Discoveries? How LLMs (and Morphik) Are Learning to Read Science

LLM Science Battle

A technical exploration of why even natively multimodal LLMs struggle with diagram interpretation in documents

When Multimodal Models Go Blind

Morphik’s cache-augmented generation (CAG) gives large language models a memory upgrade, making them 10× faster than traditional RAG by storing long-term context in the transformer key-value cache.

Cache-Augmented Generation – Teaching an AI to Remember for Lightning-Fast Answers

Simple health check endpoint that returns 200 OK.

Ping Health

Retrieve relevant chunks.

Args:
    request: RetrieveRequest containing:
        - query: Search query text
        - filters: Optional metadata filters
        - k: Number of results (default: 4)
        - min_score: Minimum similarity threshold (default: 0.0)
        - use_reranking: Whether to use reranking
        - use_colpali: Whether to use ColPali-style embedding model
        - folder_name: Optional folder to scope the search to
        - end_user_id: Optional end-user ID to scope the search to
    auth: Authentication context

Returns:
    List[ChunkResult]: List of relevant chunks

Retrieve Chunks

Retrieve relevant documents.

Args:
    request: RetrieveRequest containing:
        - query: Search query text
        - filters: Optional metadata filters
        - k: Number of results (default: 4)
        - min_score: Minimum similarity threshold (default: 0.0)
        - use_reranking: Whether to use reranking
        - use_colpali: Whether to use ColPali-style embedding model
        - folder_name: Optional folder to scope the search to
        - end_user_id: Optional end-user ID to scope the search to
    auth: Authentication context

Returns:
    List[DocumentResult]: List of relevant documents

Retrieve Documents

Retrieve multiple documents by their IDs in a single batch operation.

Args:
    request: Dictionary containing:
        - document_ids: List of document IDs to retrieve
        - folder_name: Optional folder to scope the operation to
        - end_user_id: Optional end-user ID to scope the operation to
    auth: Authentication context

Returns:
    List[Document]: List of documents matching the IDs

Batch Get Documents

Retrieve specific chunks by their document ID and chunk number in a single batch operation.

Args:
    request: Dictionary containing:
        - sources: List of ChunkSource objects (with document_id and chunk_number)
        - folder_name: Optional folder to scope the operation to
        - end_user_id: Optional end-user ID to scope the operation to
        - use_colpali: Whether to use ColPali-style embedding
    auth: Authentication context

Returns:
    List[ChunkResult]: List of chunk results

Batch Get Chunks

Generate completion using relevant chunks as context.

When graph_name is provided, the query will leverage the knowledge graph
to enhance retrieval by finding relevant entities and their connected documents.

Args:
    request: CompletionQueryRequest containing:
        - query: Query text
        - filters: Optional metadata filters
        - k: Number of chunks to use as context (default: 4)
        - min_score: Minimum similarity threshold (default: 0.0)
        - max_tokens: Maximum tokens in completion
        - temperature: Model temperature
        - use_reranking: Whether to use reranking
        - use_colpali: Whether to use ColPali-style embedding model
        - graph_name: Optional name of the graph to use for knowledge graph-enhanced retrieval
        - hop_depth: Number of relationship hops to traverse in the graph (1-3)
        - include_paths: Whether to include relationship paths in the response
        - prompt_overrides: Optional customizations for entity extraction, resolution, and query prompts
        - folder_name: Optional folder to scope the operation to
        - end_user_id: Optional end-user ID to scope the operation to
        - schema: Optional schema for structured output
        - chat_id: Optional chat conversation identifier for maintaining history
    auth: Authentication context

Returns:
    CompletionResponse: Generated text completion or structured output

Query Completion

Retrieve the message history for a chat conversation.

Args:
    chat_id: Identifier of the conversation whose history should be loaded.
    auth: Authentication context used to verify access to the conversation.
    redis: Redis connection where chat messages are stored.

Returns:
    A list of :class:`ChatMessage` objects or an empty list if no history
    exists.

Get Chat History

Execute an agent-style query using the :class:`MorphikAgent`.

Args:
    request: The query payload containing the natural language question.
    auth: Authentication context used to enforce limits and access control.

Returns:
    A dictionary with the agent's full response.

Agent Query

List accessible documents.

Args:
    auth: Authentication context
    skip: Number of documents to skip
    limit: Maximum number of documents to return
    filters: Optional metadata filters
    folder_name: Optional folder to scope the operation to
    end_user_id: Optional end-user ID to scope the operation to

Returns:
    List[Document]: List of accessible documents

List Documents

Retrieve a single document by its external identifier.

Args:
    document_id: External ID of the document to fetch.
    auth: Authentication context used to verify access rights.

Returns:
    The :class:`Document` metadata if found.

Get Document

Delete a document and all associated data.

This endpoint deletes a document and all its associated data, including:
- Document metadata
- Document content in storage
- Document chunks and embeddings in vector store

Args:
    document_id: ID of the document to delete
    auth: Authentication context (must have write access to the document)

Returns:
    Deletion status

Delete Document

Get the processing status of a document.

Args:
    document_id: ID of the document to check
    auth: Authentication context

Returns:
    Dict containing status information for the document

Get Document Status

Get document by filename.

Args:
    filename: Filename of the document to retrieve
    auth: Authentication context
    folder_name: Optional folder to scope the operation to
    end_user_id: Optional end-user ID to scope the operation to

Returns:
    Document: Document metadata if found and accessible

Get Document By Filename

Update a document with new text content using the specified strategy.

Args:
    document_id: ID of the document to update
    request: Text content and metadata for the update
    update_strategy: Strategy for updating the document (default: 'add')
    auth: Authentication context

Returns:
    Document: Updated document metadata

Update Document Text

Update a document with content from a file using the specified strategy.

Args:
    document_id: ID of the document to update
    file: File to add to the document
    metadata: JSON string of metadata to merge with existing metadata
    rules: JSON string of rules to apply to the content
    update_strategy: Strategy for updating the document (default: 'add')
    use_colpali: Whether to use multi-vector embedding
    auth: Authentication context

Returns:
    Document: Updated document metadata

Update Document File

Update only a document's metadata.

Args:
    document_id: ID of the document to update
    metadata: New metadata to merge with existing metadata
    auth: Authentication context

Returns:
    Document: Updated document metadata

Update Document Metadata

Get usage statistics for the authenticated user.

Args:
    auth: Authentication context identifying the caller.

Returns:
    A mapping of operation types to token usage counts.

Get Usage Stats

Retrieve recent telemetry records for the user or application.

Args:
    auth: Authentication context; admin users receive global records.
    operation_type: Optional operation type to filter by.
    since: Only return records newer than this timestamp.
    status: Optional status filter (e.g. ``success`` or ``error``).

Returns:
    A list of usage entries sorted by timestamp, each represented as a
    dictionary.

Get Recent Usage

Create a persistent cache for low-latency completions.

Args:
    name: Unique identifier for the cache.
    model: The model name to use when generating completions.
    gguf_file: Path to the ``gguf`` weights file to load.
    filters: Optional metadata filters used to select documents.
    docs: Explicit list of document IDs to include in the cache.
    auth: Authentication context used for permission checks.

Returns:
    A dictionary describing the created cache.

Create Cache

Retrieve information about a specific cache.

Args:
    name: Name of the cache to inspect.
    auth: Authentication context used to authorize the request.

Returns:
    A dictionary with a boolean ``exists`` field indicating whether the
    cache is loaded.

Get Cache

Refresh an existing cache with newly available documents.

Args:
    name: Identifier of the cache to update.
    auth: Authentication context used for permission checks.

Returns:
    A dictionary indicating whether any documents were added.

Update Cache

Manually add documents to an existing cache.

Args:
    name: Name of the target cache.
    docs: List of document IDs to insert.
    auth: Authentication context used for authorization.

Returns:
    A dictionary indicating whether the documents were queued for addition.

Add Docs To Cache

Generate a completion using a pre-populated cache.

Args:
    name: Name of the cache to query.
    query: Prompt text to send to the model.
    max_tokens: Optional maximum number of tokens to generate.
    temperature: Optional sampling temperature for the model.
    auth: Authentication context for permission checks.

Returns:
    A :class:`CompletionResponse` object containing the model output.

Query Cache

Create a new graph based on document contents.

The graph is created asynchronously. A stub graph record is returned with
``status = "processing"`` while a background task extracts entities and
relationships.

Args:
    request: Graph creation parameters including name and optional filters.
    auth: Authentication context authorizing the operation.

Returns:
    The placeholder :class:`Graph` object which clients can poll for status.

Create Graph

List all folders the user has access to.

Args:
    auth: Authentication context

Returns:
    List[Folder]: List of folders

List Folders

Create a new folder.

Args:
    folder_create: Folder creation request containing name and optional description
    auth: Authentication context

Returns:
    Folder: Created folder

Create Folder

Get a folder by ID.

Args:
    folder_id: ID of the folder
    auth: Authentication context

Returns:
    Folder: Folder if found and accessible

Get Folder

Delete a folder and all associated documents.

Args:
    folder_name: Name of the folder to delete
    auth: Authentication context (must have write access to the folder)

Returns:
    Deletion status

Delete Folder

Add a document to a folder.

Args:
    folder_id: ID of the folder
    document_id: ID of the document
    auth: Authentication context

Returns:
    Success status

Add Document To Folder

Remove a document from a folder.

Args:
    folder_id: ID of the folder
    document_id: ID of the document
    auth: Authentication context

Returns:
    Success status

Remove Document From Folder

Get a graph by name.

This endpoint retrieves a graph by its name if the user has access to it.

Args:
    name: Name of the graph to retrieve
    auth: Authentication context
    folder_name: Optional folder to scope the operation to
    end_user_id: Optional end-user ID to scope the operation to

Returns:
    Graph: The requested graph object

Get Graph

List all graphs the user has access to.

This endpoint retrieves all graphs the user has access to.

Args:
    auth: Authentication context
    folder_name: Optional folder to scope the operation to
    end_user_id: Optional end-user ID to scope the operation to

Returns:
    List[Graph]: List of graph objects

List Graphs

Update an existing graph with new documents.

This endpoint processes additional documents based on the original graph filters
and/or new filters/document IDs, extracts entities and relationships, and
updates the graph with new information.

Args:
    name: Name of the graph to update
    request: UpdateGraphRequest containing:
        - additional_filters: Optional additional metadata filters to determine which new documents to include
        - additional_documents: Optional list of additional document IDs to include
        - prompt_overrides: Optional customizations for entity extraction and resolution prompts
        - folder_name: Optional folder to scope the operation to
        - end_user_id: Optional end-user ID to scope the operation to
    auth: Authentication context

Returns:
    Graph: The updated graph object

Update Graph

Generate a development URI for running Morphik locally.

Args:
    name: Developer name to embed in the token payload.
    expiry_days: Number of days the generated token should remain valid.

Returns:
    A dictionary containing the ``uri`` that can be used to connect to the
    local instance.

Generate Local Uri

Generate an authenticated URI for a cloud-hosted Morphik application.

Args:
    request: Parameters for URI generation including ``app_id`` and ``name``.
    authorization: Bearer token of the user requesting the URI.

Returns:
    A dictionary with the generated ``uri`` and associated ``app_id``.

Generate Cloud Uri

Set extraction rules for a folder.

Args:
    folder_id: ID of the folder to set rules for
    request: SetFolderRuleRequest containing metadata extraction rules
    auth: Authentication context
    apply_to_existing: Whether to apply rules to existing documents in the folder

Returns:
    Success status with processing results

Set Folder Rule

List chat conversations available to the current user.

Args:
    auth: Authentication context containing user and app identifiers.
    limit: Maximum number of conversations to return.

Returns:
    A list of dictionaries describing each conversation, ordered by most
    recent activity.

List Chat Conversations

Ingest a **text** document.

Args:
    request: IngestTextRequest payload containing:
        • content – raw text to ingest.
        • filename – optional filename to help detect MIME-type.
        • metadata – optional JSON metadata dict.
        • rules – optional list of extraction / NL rules.
        • folder_name – optional folder scope.
        • end_user_id – optional end-user scope.
    auth: Decoded JWT context (injected).

Returns:
    Document metadata row representing the newly-ingested text.

Ingest Text

Ingest a **file** asynchronously.

The file is uploaded to object storage, a *Document* stub is persisted
with ``status='processing'`` and a background worker picks up the heavy
parsing / chunking work.

Args:
    file: Uploaded file from multipart/form-data.
    metadata: JSON-string representing user metadata.
    rules: JSON-string with extraction / NL rules list.
    auth: Caller context – must include *write* permission.
    use_colpali: Switch to multi-vector embeddings.
    folder_name: Optionally scope doc to a folder.
    end_user_id: Optionally scope doc to an end-user.
    redis: arq redis connection – used to enqueue the job.

Returns:
    Document stub with ``status='processing'``.

Ingest File

Batch ingest **multiple files** (async).

Each file is treated the same as :func:`ingest_file` but sharing the same
request avoids many round-trips. All heavy work is still delegated to the
background worker pool.

Args:
    files: List of files to upload.
    metadata: Either a single JSON-string dict or list of dicts matching
        the number of files.
    rules: Either a single rules list or list-of-lists per file.
    use_colpali: Enable multi-vector embeddings.
    folder_name: Optional folder scoping for **all** files.
    end_user_id: Optional end-user scoping for **all** files.
    auth: Caller context with *write* permission.
    redis: arq redis connection to enqueue jobs.

Returns:
    BatchIngestResponse summarising created documents & errors.

Batch Ingest Files

Generate a cloud URI for *request.app_id* owned by the calling user.

The *user_id* is derived from the bearer token.  The caller can therefore
not create applications for *other* users unless their token carries the
``admin`` permission (mirroring the community behaviour).

Create App

Provision a **brand-new** Neon database for *request.app_name*.

The caller must be authenticated to the dedicated Morphik instance.  The
authenticated user (represented by the JWT's *user_id*) becomes the owner
of the provisioned app.

Create App Route

Destroy the Neon project and metadata associated with *app_name*.

Only the owner of the application (identified via *auth.user_id*) may
perform this destructive action.

Delete App Route

Checks the current authentication status for the given connector type.

Get Auth Status For Connector

Return the provider's *authorization_url* for the given connector.

The method mirrors the logic of the `/auth/initiate` endpoint but sends a
JSON payload instead of a redirect so that browsers can stay on the same
origin until they intentionally navigate away.

Get Initiate Auth Url

Handles the OAuth 2.0 callback from the authentication provider.
Validates state, finalizes authentication, and stores credentials.

Connector Oauth Callback

Lists files and folders from the specified connector.

List Files For Connector

Downloads a file from the connector and ingests it into Morphik via DocumentService.

Ingest File From Connector

Disconnects the user from the specified connector by removing stored credentials.

Disconnect From Connector

Main client for document operations in Morphik

Morphik

close

ingest_text

ingest_file

retrieve_chunks

retrieve_docs

Generate completion using relevant chunks as context

query

Execute an agentic query with autonomous tool access and conversation handling

agent_query

list_documents

get_document

get_document_by_filename

Organize and isolate data into logical folder groups in Morphik

Folder Management

Organize and isolate data by end user in Morphik

User Management

update_document_with_text

Update a document with content from a file

update_document_with_file

update_document_metadata

Update a document identified by filename with new text content

update_document_by_filename_with_text

Update a document identified by filename with content from a file

update_document_by_filename_with_file

Update a document's metadata using filename to identify the document

update_document_by_filename_metadata

Retrieve multiple documents by their IDs in a single batch operation

batch_get_documents

Retrieve specific chunks by their document ID and chunk number

batch_get_chunks

create_graph

get_graph

list_graphs

Create a new cache with specified configuration

create_cache

get_cache

Overview of building a retrieval augmented generation workflow

How do I set up RAG?

Understanding when and how to use the intelligent Morphik Agent for complex analysis tasks

How to use the Morphik Agent

Techniques for searching document collections efficiently

How do I perform search over documents?

Best practices for getting the most relevant results from your data

How can I improve retrieval accuracy?

Guidance on splitting data for optimal retrieval

How should I chunk my documents?

Combining text, images, and other data types in a search system

API Reference

Ingestion

Enterprise

EE - Connectors

Delete Cloud App

Headers

Query Parameters

Response