Skip to content

OpenRAG is a comprehensive, single package Retrieval-Augmented Generation platform built on Langflow, Docling, and Opensearch.

Python
3.4 KB
Raw Blame
import {
  type UseMutationOptions,
  useMutation,
  useQueryClient,
} from "@tanstack/react-query";
import { toast } from "sonner";
import { apiClient } from "@/lib/api-client";
import { formatProviderErrorMessage } from "@/lib/chat-stream-errors";
import { refreshModelCatalog } from "../queries/useGetModelsQuery";
import { useUpdateOnboardingStateMutation } from "./useUpdateOnboardingStateMutation";

export interface OnboardingVariables {
  // Provider selection
  llm_provider?: string;
  embedding_provider?: string;

  // Models
  embedding_model?: string;
  llm_model?: string;

  // Provider-specific credentials
  openai_api_key?: string;
  anthropic_api_key?: string;
  watsonx_api_key?: string;
  watsonx_endpoint?: string;
  watsonx_project_id?: string;
  ollama_endpoint?: string;
  provider_credentials?: Record<string, Record<string, string>>;
  provider_credential_removals?: Record<string, string[]>;
  provider_auth_methods?: Record<string, string>;
}

interface OnboardingResponse {
  message: string;
  edited: boolean;
  openrag_docs_filter_id?: string;
  task_id?: string;
  chunk_size_adjusted_to?: number | null;
}

async function submitOnboarding(
  variables: OnboardingVariables,
): Promise<OnboardingResponse> {
  const response = await apiClient.post<OnboardingResponse>(
    "/onboarding",
    variables,
  );

  if (response.status < 200 || response.status >= 300) {
    const error = (response.data ?? {}) as unknown as Record<string, unknown>;
    const raw =
      error && typeof error === "object" && typeof error.error === "string"
        ? error.error
        : "Failed to complete onboarding";
    throw new Error(formatProviderErrorMessage(raw));
  }

  return response.data;
}

export const useOnboardingMutation = (
  options?: Omit<
    UseMutationOptions<OnboardingResponse, Error, OnboardingVariables>,
    "mutationFn"
  >,
) => {
  const queryClient = useQueryClient();

  const updateOnboardingMutation = useUpdateOnboardingStateMutation();

  return useMutation({
    ...options,
    mutationFn: submitOnboarding,
    onSuccess: async (data, variables, onMutateResult, context) => {
      // Save OpenRAG docs filter ID if sample data was ingested
      if (data.openrag_docs_filter_id) {
        await updateOnboardingMutation.mutateAsync({
          openrag_docs_filter_id: data.openrag_docs_filter_id,
        });
      }
      if (typeof data.chunk_size_adjusted_to === "number") {
        toast.info(`Chunk size reduced to ${data.chunk_size_adjusted_to}`, {
          description:
            "OpenRAG adjusted ingestion chunks to stay within watsonx.ai on-prem embedding limits.",
        });
      }
      await options?.onSuccess?.(data, variables, onMutateResult, context);
    },
    onSettled: async (data, error, variables, onMutateResult, context) => {
      // Invalidate settings query to refetch updated onboarding state
      await queryClient.invalidateQueries({ queryKey: ["settings"] });
      // The catalogue lists a cluster-hosted provider with its saved
      // credentials, which onboarding has just written. Not awaited: the
      // catalogue route lists every cluster provider live, and the mutation
      // stays pending until onSettled resolves, which would stall the
      // embedding step's progress behind a slow cluster.
      refreshModelCatalog(queryClient);
      await options?.onSettled?.(
        data,
        error,
        variables,
        onMutateResult,
        context,
      );
    },
  });
};