vllm serving capabilities

Signed-off-by: Brent Salisbury <[email protected]>

Author: nerdalert

src/Containerfile

@@ -1,14 +1,17 @@
 FROM registry.access.redhat.com/ubi9/nodejs-22:9.5-1730543890
 
+USER root
+
 WORKDIR /opt/app-root/src
 
-COPY package*.json ./
+COPY ./ .
+
+RUN dnf install -y jq
+RUN mkdir -p node_modules
+RUN chown -R default:root package*.json next-env.d.ts node_modules /opt/app-root/src/src/healthcheck-probe.sh
 
-USER root
-RUN chown -R default:root /opt/app-root/src/package*.json
 USER default
-RUN npm install
-COPY ./ .
 
+RUN npm install
 RUN npm run build
 CMD ["npm", "run", "start"]

src/app/api/envConfig/route.ts

@@ -15,7 +15,9 @@ export async function GET() {
     UPSTREAM_REPO_OWNER: process.env.NEXT_PUBLIC_TAXONOMY_REPO_OWNER || '',
     UPSTREAM_REPO_NAME: process.env.NEXT_PUBLIC_TAXONOMY_REPO || '',
     DEPLOYMENT_TYPE: process.env.IL_UI_DEPLOYMENT || '',
-    EXPERIMENTAL_FEATURES: process.env.NEXT_PUBLIC_EXPERIMENTAL_FEATURES || ''
+    ENABLE_DEV_MODE: process.env.IL_ENABLE_DEV_MODE || 'false',
+    EXPERIMENTAL_FEATURES: process.env.NEXT_PUBLIC_EXPERIMENTAL_FEATURES || '',
+    TAXONOMY_ROOT_DIR: process.env.NEXT_PUBLIC_TAXONOMY_ROOT_DIR || ''
   };
 
   return NextResponse.json(envConfig);

src/app/api/fine-tune/git/branches/route.ts

@@ -0,0 +1,65 @@
+// src/app/api/native/fine-tune/git/branches/route.ts
+import { NextResponse } from 'next/server';
+import * as git from 'isomorphic-git';
+import fs from 'fs';
+import path from 'path';
+
+const REMOTE_TAXONOMY_ROOT_DIR = process.env.NEXT_PUBLIC_TAXONOMY_ROOT_DIR || '';
+
+export async function GET() {
+  const REPO_DIR = path.join(REMOTE_TAXONOMY_ROOT_DIR, '/taxonomy');
+  try {
+    console.log(`Checking local taxonomy directory for branches: ${REPO_DIR}`);
+
+    // Ensure the repository path exists
+    if (!fs.existsSync(REPO_DIR)) {
+      console.log('Local repository path does not exist:', REPO_DIR);
+      return NextResponse.json({ error: 'Local repository path does not exist.' }, { status: 400 });
+    }
+
+    console.log('Local taxonomy directory exists. Proceeding with branch listing.');
+
+    // List all branches in the repository
+    const branches = await git.listBranches({ fs, dir: REPO_DIR });
+    console.log(`Branches found: ${branches.join(', ')}`);
+
+    const branchDetails = [];
+
+    for (const branch of branches) {
+      const branchCommit = await git.resolveRef({
+        fs,
+        dir: REPO_DIR,
+        ref: branch
+      });
+      const commitDetails = await git.readCommit({
+        fs,
+        dir: REPO_DIR,
+        oid: branchCommit
+      });
+
+      const commitMessage = commitDetails.commit.message;
+
+      // Check for Signed-off-by line
+      const signoffMatch = commitMessage.match(/^Signed-off-by: (.+)$/m);
+      const signoff = signoffMatch ? signoffMatch[1] : null;
+      const messageStr = commitMessage.split('Signed-off-by');
+
+      branchDetails.push({
+        name: branch,
+        creationDate: commitDetails.commit.committer.timestamp * 1000,
+        message: messageStr[0].replace(/\n+$/, ''),
+        author: signoff
+      });
+    }
+
+    // Sort by creation date, newest first
+    branchDetails.sort((a, b) => b.creationDate - a.creationDate);
+
+    console.log('Total branches present in native taxonomy (fine-tune):', branchDetails.length);
+
+    return NextResponse.json({ branches: branchDetails }, { status: 200 });
+  } catch (error) {
+    console.error('Failed to list branches from local taxonomy (fine-tune):', error);
+    return NextResponse.json({ error: 'Failed to list branches from local taxonomy (fine-tune)' }, { status: 500 });
+  }
+}

src/app/api/fine-tune/model/train/route.ts

@@ -1,4 +1,4 @@
-// src/app/api/fine-tune/model/train
+// src/app/api/fine-tune/model/train/route.ts
 'use server';
 
 import { NextResponse } from 'next/server';
@@ -8,16 +8,21 @@ export async function POST(request: Request) {
     console.log('Received train job request');
 
     // Parse the request body for required data
-    const { modelName, branchName } = await request.json();
+    const { modelName, branchName, epochs } = await request.json();
     const API_SERVER = process.env.NEXT_PUBLIC_API_SERVER!;
 
-    console.log('Request body:', { modelName, branchName });
+    console.log('Request body:', { modelName, branchName, epochs });
 
     if (!modelName || !branchName) {
       console.error('Missing required parameters: modelName and branchName');
       return NextResponse.json({ error: 'Missing required parameters: modelName and branchName' }, { status: 400 });
     }
 
+    // Validate epochs if provided
+    if (epochs !== undefined && (typeof epochs !== 'number' || epochs <= 0)) {
+      return NextResponse.json({ error: "'epochs' must be a positive integer" }, { status: 400 });
+    }
+
     // Forward the request to the API server
     const endpoint = `${API_SERVER}/model/train`;
 
@@ -30,7 +35,8 @@ export async function POST(request: Request) {
       },
       body: JSON.stringify({
         modelName,
-        branchName
+        branchName,
+        epochs
       })
     });
 
@@ -40,7 +46,8 @@ export async function POST(request: Request) {
     });
 
     if (!response.ok) {
-      console.error('Error response from API server:', response.status, response.statusText);
+      const errorText = await response.text();
+      console.error('Error response from API server:', response.status, response.statusText, errorText);
       return NextResponse.json({ error: 'Failed to train the model on the API server' }, { status: response.status });
     }
 

src/app/api/fine-tune/model/vllm-status/route.ts

@@ -0,0 +1,31 @@
+// src/app/api/model/vllm-status/route.ts
+'use server';
+
+import { NextResponse } from 'next/server';
+
+export async function GET(request: Request) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const modelName = searchParams.get('modelName');
+    if (!modelName) {
+      return NextResponse.json({ error: 'Missing modelName query param' }, { status: 400 });
+    }
+
+    const API_SERVER = process.env.NEXT_PUBLIC_API_SERVER!;
+    const endpoint = `${API_SERVER}/vllm-status?model_name=${modelName}`;
+
+    console.log('Forwarding request to vllm-status:', endpoint);
+
+    const response = await fetch(endpoint);
+    if (!response.ok) {
+      console.error('vllm-status error from API server:', response.status, response.statusText);
+      return NextResponse.json({ error: 'Failed to get vllm status' }, { status: response.status });
+    }
+
+    const statusData = await response.json();
+    return NextResponse.json(statusData, { status: 200 });
+  } catch (error) {
+    console.error('Unexpected error in vllm-status route:', error);
+    return NextResponse.json({ error: 'Unexpected error fetching vllm status' }, { status: 500 });
+  }
+}

src/app/api/fine-tune/pipeline/generate-train/route.ts

@@ -1,17 +1,26 @@
+// src/app/api/fine-tune/pipeline/generate-train/route.ts
 'use server';
 
 import { NextResponse } from 'next/server';
 
 export async function POST(request: Request) {
   try {
     // Parse the request body for required data
-    const { modelName, branchName } = await request.json();
+    const { modelName, branchName, epochs } = await request.json();
     const API_SERVER = process.env.NEXT_PUBLIC_API_SERVER!;
 
+    console.log('Request body:', { modelName, branchName, epochs });
+
     if (!modelName || !branchName) {
+      console.error('Missing required parameters: modelName and branchName');
       return NextResponse.json({ error: 'Missing required parameters: modelName and branchName' }, { status: 400 });
     }
 
+    // Validate epochs if provided
+    if (epochs !== undefined && (typeof epochs !== 'number' || epochs <= 0)) {
+      return NextResponse.json({ error: "'epochs' must be a positive integer" }, { status: 400 });
+    }
+
     // Forward the request to the API server's pipeline endpoint
     const endpoint = `${API_SERVER}/pipeline/generate-train`;
 
@@ -22,19 +31,42 @@ export async function POST(request: Request) {
       },
       body: JSON.stringify({
         modelName,
-        branchName
+        branchName,
+        epochs
       })
     });
 
+    console.log('Response from API server:', {
+      status: response.status,
+      statusText: response.statusText
+    });
+
     if (!response.ok) {
-      console.error('Error response from API server (pipeline):', response.status, response.statusText);
-      return NextResponse.json({ error: 'Failed to run generate-train pipeline on the API server' }, { status: response.status });
+      const errorText = await response.text();
+      console.error('Error response from API server:', response.status, response.statusText, errorText);
+      return NextResponse.json({ error: 'Failed to train the model on the API server' }, { status: response.status });
+    }
+
+    const responseData;
+    try {
+      const text = await response.text();
+      responseData = text ? JSON.parse(text) : {};
+      console.log('Parsed response data:', responseData);
+    } catch (error) {
+      console.error('Error parsing JSON response from API server:', error);
+      return NextResponse.json({ error: 'Invalid JSON response from the API server' }, { status: 500 });
+    }
+
+    if (!responseData.job_id) {
+      console.error('Missing job_id in API server response:', responseData);
+      return NextResponse.json({ error: 'API server response does not contain job_id' }, { status: 500 });
     }
 
-    const responseData = await response.json();
+    // Return the response from the API server to the client
+    console.log('Returning success response with job_id:', responseData.job_id);
     return NextResponse.json(responseData, { status: 200 });
   } catch (error) {
-    console.error('Error during generate-train pipeline:', error);
-    return NextResponse.json({ error: 'An error occurred during generate-train pipeline' }, { status: 500 });
+    console.error('Unexpected error during training:', error);
+    return NextResponse.json({ error: 'An unexpected error occurred during training' }, { status: 500 });
   }
 }