// customize
const inkeepSettings = {
    isOpen: true,
    baseSettings: {
        apiKey: '3adc15f45617826bb73c0a4cb9fb3a06547b6ab7f90c819e',
        integrationId: 'clv1yuc8f0002vzhxbzwy26yx',
        organizationId: 'clu6yudh9000sajgn7nwxfve8',
        primaryBrandColor: '#26D6FF', // your brand color, widget color scheme is derived from this
        organizationDisplayName: 'R2R',
        theme: {
          colorMode: {
            forcedColorMode: 'dark', // to sync dark mode with the widget
          },
        },
    },
    aiChatSettings: {
      // ...optional settings
      botAvatarSrcUrl:
        "https://www.sciphi.ai/screenshots/logo222_cut.png",
      quickQuestions: [
        "How do I get started?",
        "How does R2R implement hybrid search?",
        "How do I use the R2R API?",
        // "How do I use ",
        // "Example question 3?",
      ],
    },
    modalSettings: {
      isShortcutKeyEnabled: false, // disable default cmd+k behavior
      // ...optional settings
    },
  };

  // The Mintlify search triggers, which we'll reuse to trigger the Inkeep modal
  const searchButtonContainerIds = [
    "search-bar-entry",
    "search-bar-entry-mobile",
  ];

  // Clone and replace, needed to remove existing event listeners
  const clonedSearchButtonContainers = searchButtonContainerIds.map((id) => {
    const originalElement = document.getElementById(id);
    const clonedElement = originalElement.cloneNode(true);
    originalElement.parentNode.replaceChild(clonedElement, originalElement);

    return clonedElement;
  });

  // Load the Inkeep component library
  const inkeepScript = document.createElement("script");
  inkeepScript.type = "module";
  inkeepScript.src =
    "https://unpkg.com/@inkeep/widgets-embed@latest/dist/embed.js";
  document.body.appendChild(inkeepScript);

  // Once the Inkeep library is loaded, instantiate the UI components
  inkeepScript.addEventListener("load", function () {
    // Customization settings

    // for syncing with dark mode
    const colorModeSettings = {
      observedElement: document.documentElement,
      isDarkModeCallback: (el) => {
        return el.classList.contains("dark");
      },
      colorModeAttribute: "class",
    };

    // Instantiate the "Ask AI" pill chat button
    Inkeep().embed({
      componentType: "ChatButton",
      colorModeSync: colorModeSettings,
      properties: inkeepSettings,
    });

    // Instantiate the search bar modal
    const inkeepSearchModal = Inkeep({
      ...inkeepSettings.baseSettings,
    }).embed({
      componentType: "CustomTrigger",
      colorModeSync: colorModeSettings,
      properties: {
        ...inkeepSettings,
        isOpen: false,
        onClose: () => {
          inkeepSearchModal.render({
            isOpen: false,
          });
        },
      },
    });

    // When the Mintlify search bar elements are clicked, open the Inkeep search modal
    clonedSearchButtonContainers.forEach((trigger) => {
      trigger.addEventListener("click", function () {
        inkeepSearchModal.render({
          isOpen: true,
        });
      });
    });

    // Open the Inkeep Modal with cmd+k
    window.addEventListener(
      "keydown",
      (event) => {
        if (
          (event.metaKey || event.ctrlKey) &&
          (event.key === "k" || event.key === "K")
        ) {
          event.stopPropagation();
          inkeepSearchModal.render({ isOpen: true });
          return false;
        }
      },
      true
    );
  });


Community

Build, scale, and manage user-facing Retrieval-Augmented Generation applications.

Introduction

Documentation

API Reference

Cookbooks

R2R GitHub

Support

Update existing files in the system.

This endpoint supports multipart/form-data requests, enabling you to update files and their associated metadatas into R2R.

A valid user authentication token is required to access this endpoint, as regular users can only update their own files. More expansive collection permissioning is under development.

Update Files

The ID of the document that was ingested.

Document Ids

A message describing the result of the ingestion request.

Message

Task Id

UpdateResponse

Location

Error Type

ValidationError

Body_update_files_app_v2_update_files_post

HTTPBearer

ResultsWrapper[UpdateResponse]

HTTPValidationError

Update Files App

System

What's New

Quickstart

Key terms and environment settings for R2R

Glossary

Learn how to configure your R2R deployment

Postgres

Learn how to configure LLMs in your R2R deployment

LLMs

Learn how to configure RAG in your R2R deployment

Learn how to configure and manage prompts in your R2R deployment

Prompts

Overview

Embedding

Configure your R2R knowledge graph provider.

Configuration for Restructuring data after ingestion using Knowledge Graphs

KG Enrichment

Vector Search

Knowledge Graph

Learn how to run a Retrieval-Augmented Generation system locally using R2R

Local LLMs

Azure

Learn how to deploy R2R into Google Cloud

SciPhi Enterprise

Core Logic

R2RConfig

R2RBuilder

Learn how to configure and use the authentication provider in R2R

Crypto & Auth

Configure and use multiple Language Model providers in R2R

Language Models (LLMs)

Learn how to configure and use the database provider in R2R

Database

Learn how to configure and use the knowledge graph provider in R2R

Learn about R2R telemetry and how to manage it

Telemetry

Powerful document ingestion, search, and RAG capabilities at your fingertips

R2R API Reference

Ingest files into the system.

This endpoint supports multipart/form-data requests, enabling you to ingest files and their associated metadatas into R2R.

A valid user authentication token is required to access this endpoint, as regular users can only ingest files for their own access. More expansive collection permissioning is under development.

Ingest Files

Ingest text chunks into the system.

This endpoint supports multipart/form-data requests, enabling you to ingest pre-parsed text chunks into R2R.

A valid user authentication token is required to access this endpoint, as regular users can only ingest chunks for their own access. More expansive collection permissioning is under development.

Ingest Chunks

Create Vector Index

Creating a graph on your documents. This endpoint takes input a list of document ids and KGCreationSettings.
If document IDs are not provided, the graph will be created on all documents in the system.
This step extracts the relevant entities and relationships from the documents and creates a graph based on the extracted information.
In order to do GraphRAG, you will need to run the enrich_graph endpoint.

Create Graph

This endpoint enriches the graph with additional information.
It creates communities of nodes based on their similarity and adds embeddings to the graph.
This step is necessary for GraphRAG to work.

Enrich Graph

Retrieve entities from the knowledge graph.

Entities

Retrieve triples from the knowledge graph.

Triples

Retrieve communities from the knowledge graph.

Communities

Perform a search query on the vector database and knowledge graph.

This endpoint allows for complex filtering of search results using PostgreSQL-based queries.
Filters can be applied to various fields such as document_id, and internal metadata values.


Allowed operators include `eq`, `neq`, `gt`, `gte`, `lt`, `lte`, `like`, `ilike`, `in`, and `nin`.

Search

Execute a RAG (Retrieval-Augmented Generation) query.

This endpoint combines search results with language model generation.
It supports the same filtering capabilities as the search endpoint,
allowing for precise control over the retrieved context.

The generation process can be customized using the rag_generation_config parameter.

Implement an agent-based interaction for complex query processing.

This endpoint supports multi-turn conversations and can handle complex queries
by breaking them down into sub-tasks. It uses the same filtering capabilities
as the search and RAG endpoints for retrieving relevant information.

The agent's behavior can be customized using the rag_generation_config and
task_prompt_override parameters.

Agent

Document Chunks

Delete

Documents Overview

Register a new user with the given email and password.

Register

Verify a user's email address.

This endpoint is used to confirm a user's email address using the verification code
sent to their email after registration.

Verify Email

Authenticate a user and provide access tokens.

This endpoint authenticates a user using their email (username) and password,
and returns access and refresh tokens upon successful authentication.

Login

Get the current user's profile information.

This endpoint returns the profile information of the currently authenticated user.

Get User

Update the current user's profile information.

This endpoint allows the authenticated user to update their profile information.

Update User

Delete a user account.

This endpoint allows users to delete their own account or, for superusers,
to delete any user account.

Delete User

Refresh the access token using a refresh token.

This endpoint allows users to obtain a new access token using their refresh token.

Refresh Access Token

Log out the current user.

This endpoint invalidates the user's current access token, effectively logging them out.

Logout

Change the authenticated user's password.

This endpoint allows users to change their password by providing their current password
and a new password.

Change Password

Request a password reset for a user.

This endpoint initiates the password reset process by sending a reset link
to the specified email address.

API Documentation

Document Ingestion

Knowledge Graph

Retrieval

User Documents

User Auth

Collections

Admin

Analytics and Observability

Status

Update Files

Authorizations

Body

Response