How to Integrate Algorithmia with V0

Before writing integration code, decide which ML platform you will use. This choice determines the API endpoint format and authentication method your Next.js route will use. Here are the three most viable options as of 2026, now that the original Algorithmia API is discontinued: DataRobot MLOps is the right choice if your organization already uses DataRobot Enterprise. You have deployed prediction servers accessible at endpoints like https://{host}/predApi/v1.0/deployments/{deploymentId}/predictions. Authentication is via a DataRobot API key in a datarobot-key header. DataRobot requires enterprise licensing and is not suitable for individual developers or small teams. Hugging Face Inference API is the best choice for most V0 use cases. It provides access to thousands of open-source models (NLP, image classification, audio transcription, and more) via a consistent REST API. Authentication is a simple bearer token from your HuggingFace account settings. The free tier allows limited calls; a Pro plan at $9/month provides significantly higher rate limits. Endpoint format: POST https://api-inference.huggingface.co/models/{model-id}. Replicate specializes in generative AI models — image generation, video, audio, and large language models. Predictions are asynchronous (you get a prediction ID, then poll for completion) which requires slightly more complex API route logic. Authentication is a bearer token. Usage is billed per prediction second. With your platform chosen, prompt V0 to generate the input form appropriate for your ML task. For text models, this is a textarea with a submit button. For image models, this is a file upload. For structured data models (DataRobot's specialty), this is a multi-field form matching your model's feature schema.

Create app/api/ml/predict/route.ts as the server-side proxy for your chosen ML platform. This file keeps your API key secure and handles the specific request/response format of your ML provider. For Hugging Face Inference API, the request is a POST to https://api-inference.huggingface.co/models/{model-id} with a JSON body containing inputs (the text or data to process) and optionally parameters. The Authorization header uses Bearer {HF_API_TOKEN}. The response format varies by model — text classification models return an array of objects with label and score, while text generation models return an array with generated_text. Handle model loading delays by checking for the 'loading' field in the response and implementing a retry with a short delay. For DataRobot, the request is a POST to your deployment prediction endpoint with a JSON body in the format { data: [{ feature1: value, feature2: value, ... }] }. The headers require both Authorization: Bearer {DATAROBOT_API_KEY} and datarobot-key: {DATAROBOT_API_KEY}. DataRobot returns predictions in a data array with a prediction field per row. For Replicate, model predictions are asynchronous. First POST to https://api.replicate.com/v1/predictions with Authorization: Token {REPLICATE_API_TOKEN} and a body containing version (model version hash) and input (model-specific input object). This returns a prediction object with an id and status of 'starting'. You then poll GET https://api.replicate.com/v1/predictions/{id} until status is 'succeeded', then read the output field. Implement this polling in a loop with a 1-second sleep between polls and a maximum of 30 attempts. For all platforms, normalize the response before returning it from your Next.js route — extract the prediction, confidence score, and any explanation into a consistent JSON format that your V0-generated UI expects regardless of which backend you switch to.

1import { NextRequest, NextResponse } from 'next/server';
2
3const MODEL_MAP: Record<string, string> = {
4  sentiment: 'distilbert-base-uncased-finetuned-sst-2-english',
5  classification: 'facebook/bart-large-mnli',
6  summarization: 'facebook/bart-large-cnn',
7};
8
9async function callHuggingFace(
10  modelId: string,
11  inputs: string,
12  retryOnLoad = true
13): Promise<unknown> {
14  const response = await fetch(
15    `https://api-inference.huggingface.co/models/${modelId}`,
16    {
17      method: 'POST',
18      headers: {
19        Authorization: `Bearer ${process.env.HF_API_TOKEN}`,
20        'Content-Type': 'application/json',
21      },
22      body: JSON.stringify({ inputs }),
23    }
24  );
25
26  const data = await response.json();
27
28  // Hugging Face returns { error: 'loading', estimated_time: X } while model warms up
29  if (data.error && data.error.includes('loading') && retryOnLoad) {
30    await new Promise((resolve) => setTimeout(resolve, 20000));
31    return callHuggingFace(modelId, inputs, false);
32  }
33
34  if (!response.ok) {
35    throw new Error(data.error || `HuggingFace API error: ${response.status}`);
36  }
37
38  return data;
39}
40
41export async function POST(request: NextRequest) {
42  try {
43    const { text, modelType = 'sentiment' } = await request.json();
44
45    if (!text || typeof text !== 'string') {
46      return NextResponse.json(
47        { error: 'Text input is required' },
48        { status: 400 }
49      );
50    }
51
52    const modelId = MODEL_MAP[modelType] || MODEL_MAP.sentiment;
53    const rawResponse = await callHuggingFace(modelId, text);
54
55    // Normalize text classification response
56    const results = Array.isArray(rawResponse) ? rawResponse[0] : rawResponse;
57    const topResult = Array.isArray(results)
58      ? results.sort((a: { score: number }, b: { score: number }) => b.score - a.score)[0]
59      : results;
60
61    return NextResponse.json({
62      label: topResult?.label || 'Unknown',
63      confidence: topResult?.score ? Math.round(topResult.score * 100) : 0,
64      rawResponse,
65    });
66  } catch (error) {
67    console.error('ML predict error:', error);
68    return NextResponse.json(
69      { error: error instanceof Error ? error.message : 'Prediction failed' },
70      { status: 500 }
71    );
72  }
73}

If you are integrating with DataRobot MLOps rather than Hugging Face, the API route has a different request format. DataRobot prediction servers require a specific JSON structure and two authentication headers. DataRobot deployment endpoints are provisioned through the DataRobot console. Each deployed model gets a unique prediction API URL in the format https://{hostname}/predApi/v1.0/deployments/{deploymentId}/predictions. Your organization's DataRobot administrator provides this URL and a DataRobot API key. The request body format for DataRobot structured predictions is: { data: [{ feature_name_1: value1, feature_name_2: value2, ... }] }. The feature names must exactly match the columns your model was trained on — DataRobot returns a 422 error if any expected features are missing. For each row in the data array, DataRobot returns a corresponding prediction in the response. DataRobot also supports explanations (SHAP values showing feature contributions) in the same prediction call. Pass explanatory: true in your request to receive feature importance data alongside the prediction. This is powerful for building explainable AI interfaces where users can see why the model made a specific prediction — something V0 can generate an excellent UI for with confidence bars per feature. For V0 apps targeting the enterprise DataRobot use case, the input form needs to match your model's feature schema. Generate this form in V0 by listing all the feature names and their data types (numeric, categorical) in your prompt. V0 can create a well-labeled form with appropriate input types for each feature.

1import { NextRequest, NextResponse } from 'next/server';
2
3export async function POST(request: NextRequest) {
4  try {
5    const featureData = await request.json();
6
7    const response = await fetch(
8      `${process.env.DATAROBOT_ENDPOINT_URL}/predictions`,
9      {
10        method: 'POST',
11        headers: {
12          Authorization: `Bearer ${process.env.DATAROBOT_API_KEY}`,
13          'Content-Type': 'application/json; charset=UTF-8',
14          // DataRobot requires this additional header
15          'datarobot-key': process.env.DATAROBOT_API_KEY!,
16        },
17        body: JSON.stringify({
18          data: [featureData],
19          // Include explanations if your deployment supports them
20          // explanatory: true,
21        }),
22      }
23    );
24
25    if (!response.ok) {
26      const error = await response.json();
27      return NextResponse.json(
28        { error: error.message || `DataRobot error: ${response.status}` },
29        { status: response.status }
30      );
31    }
32
33    const result = await response.json();
34    const prediction = result.data?.[0];
35
36    return NextResponse.json({
37      prediction: prediction?.prediction,
38      probability: prediction?.predictionValues?.[0]?.value,
39      explanations: prediction?.predictionExplanations || [],
40    });
41  } catch (error) {
42    console.error('DataRobot prediction error:', error);
43    return NextResponse.json(
44      { error: 'Prediction failed' },
45      { status: 500 }
46    );
47  }
48}

Add your ML platform API credentials to Vercel's environment variables. The specific variables depend on which platform you chose, but the process is the same for all. Go to Vercel Dashboard → your project → Settings → Environment Variables. Add the relevant variables for your platform. For Hugging Face: add HF_API_TOKEN with your token from huggingface.co/settings/tokens. For DataRobot: add DATAROBOT_API_KEY with your key from DataRobot Console → Developer Tools → API Keys, and DATAROBOT_ENDPOINT_URL with the full prediction endpoint URL for your deployment. For Replicate: add REPLICATE_API_TOKEN with your token from replicate.com/account/api-tokens. None of these variables should have the NEXT_PUBLIC_ prefix. All ML API tokens are server-only secrets. Exposing an ML API token in the browser would allow anyone visiting your site to use your quota and incur charges on your account. In V0-generated code, watch for any usages of ML API tokens in client components — if V0 tries to call an ML API from the browser side, refactor that code to go through your API route instead. For local development, add the same variables to .env.local. Test by running npm run dev, submitting a test input through the form, and checking the browser's network tab to confirm /api/ml/predict returns a 200 with prediction data. Check Vercel function logs after deployment for any server-side errors. For Hugging Face specifically, note that free tier tokens have rate limits of a few hundred requests per hour. If you expect higher traffic, consider a Pro subscription or dedicated inference endpoints which offer higher throughput and consistent cold-start performance.

1# .env.local — local development only
2# Hugging Face
3HF_API_TOKEN=hf_your_token_here
4
5# DataRobot (if using enterprise)
6DATAROBOT_API_KEY=your_datarobot_key
7DATAROBOT_ENDPOINT_URL=https://your-host/predApi/v1.0/deployments/deployment-id