Feature: fine-tuning and model chat eval

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

Author: nerdalert

package-lock.json

@@ -19,10 +19,16 @@
   "dependencies": {
     "@fortawesome/fontawesome-svg-core": "^6.7.2",
     "@next/env": "^15.1.4",
+    "@patternfly/chatbot": "^2.1.0-prerelease.17",
     "@patternfly/react-core": "^6.1.0",
     "@patternfly/react-icons": "^6.0.0",
     "@patternfly/react-styles": "^6.0.0",
     "axios": "^1.7.9",
+    "@patternfly/react-table": "^6.1.0",
+    "@patternfly/virtual-assistant": "^2.0.2",
+    "date-fns": "^4.1.0",
+    "dompurify": "^3.2.3",
+    "fs": "^0.0.1-security",
     "isomorphic-git": "^1.29.0",
     "js-yaml": "^4.1.0",
     "next": "^15.1.3",

package.json

@@ -0,0 +1,22 @@
+// src/pages/api/fine-tune/data-sets.ts
+'use server';
+
+import { NextRequest, NextResponse } from 'next/server';
+
+export async function GET(req: NextRequest) {
+  try {
+    const API_SERVER = process.env.NEXT_PUBLIC_API_SERVER!;
+
+    const response = await fetch(`${API_SERVER}/data`);
+    const data = await response.json();
+
+    if (!response.ok) {
+      return NextResponse.json({ error: 'Failed to fetch datasets' }, { status: response.status });
+    }
+
+    return NextResponse.json(data, { status: 200 });
+  } catch (error) {
+    console.error('Error fetching datasets:', error);
+    return NextResponse.json({ error: 'Internal Server Error' }, { status: 500 });
+  }
+}

src/app/api/fine-tune/data-sets/route.ts

@@ -0,0 +1,25 @@
+'use server';
+
+import { NextResponse } from 'next/server';
+
+export async function POST(request: Request) {
+  try {
+    const API_SERVER = process.env.NEXT_PUBLIC_API_SERVER!;
+
+    const response = await fetch(`${API_SERVER}/data/generate`, {
+      method: 'POST'
+    });
+
+    if (!response.ok) {
+      console.error('Error response from API server:', response.status, response.statusText);
+      return NextResponse.json({ error: 'Failed to generate data' }, { status: response.status });
+    }
+
+    const responseData = await response.json();
+
+    return NextResponse.json(responseData, { status: 200 });
+  } catch (error) {
+    console.error('Error generating data:', error);
+    return NextResponse.json({ error: 'An error occurred while generating data' }, { status: 500 });
+  }
+}

src/app/api/fine-tune/data/generate/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/git/branches/route.ts

@@ -0,0 +1,24 @@
+// src/app/api/fine-tune/gpu-free/route.ts
+'use server';
+
+import { NextResponse } from 'next/server';
+
+export async function GET() {
+  try {
+    const API_SERVER = process.env.NEXT_PUBLIC_API_SERVER!;
+    const endpoint = `${API_SERVER}/gpu-free`;
+
+    const resp = await fetch(endpoint);
+    if (!resp.ok) {
+      console.error('gpu-free error from API server:', resp.status, resp.statusText);
+      return NextResponse.json({ free_gpus: 0 }, { status: 200 });
+      // Return 0 in case of error
+    }
+
+    const data = await resp.json();
+    return NextResponse.json(data, { status: 200 });
+  } catch (error) {
+    console.error('Unexpected error in gpu-free route:', error);
+    return NextResponse.json({ free_gpus: 0 }, { status: 200 });
+  }
+}

src/app/api/fine-tune/gpu-free/route.ts

@@ -0,0 +1,29 @@
+// src/app/api/fine-tune/jobs/[job_id]/logs/route.ts
+import { NextResponse } from 'next/server';
+
+const API_SERVER = process.env.NEXT_PUBLIC_API_SERVER!;
+
+export async function GET(request: Request, { params }: { params: { job_id: string } }) {
+  const { job_id } = await Promise.resolve(params);
+
+  try {
+    const response = await fetch(`${API_SERVER}/jobs/${job_id}/logs`, {
+      method: 'GET'
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error('Error from API server:', errorText);
+      return NextResponse.json({ error: 'Error fetching logs' }, { status: 500 });
+    }
+
+    const logs = await response.text();
+    return new NextResponse(logs, {
+      status: 200,
+      headers: { 'Content-Type': 'text/plain' }
+    });
+  } catch (error) {
+    console.error('Error fetching logs:', error);
+    return NextResponse.json({ error: 'Error fetching logs' }, { status: 500 });
+  }
+}

src/app/api/fine-tune/jobs/[job_id]/logs/route.ts

@@ -0,0 +1,29 @@
+// src/app/api/fine-tune/jobs/[job_id]/status/route.ts
+'use server';
+
+import { NextResponse } from 'next/server';
+
+export async function GET(request: Request, { params }: { params: { job_id: string } }) {
+  const { job_id } = params;
+  const API_SERVER = process.env.NEXT_PUBLIC_API_SERVER!;
+
+  try {
+    // Forward the request to the API server
+    const response = await fetch(`${API_SERVER}/jobs/${job_id}/status`, {
+      method: 'GET'
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error('Error from API server:', errorText);
+      return NextResponse.json({ error: 'Error fetching job status' }, { status: 500 });
+    }
+
+    const result = await response.json();
+    // Return the job status to the client
+    return NextResponse.json(result, { status: 200 });
+  } catch (error) {
+    console.error('Error fetching job status:', error);
+    return NextResponse.json({ error: 'Error fetching job status' }, { status: 500 });
+  }
+}

src/app/api/fine-tune/jobs/[job_id]/status/route.ts

@@ -0,0 +1,22 @@
+// src/app/api/fine-tune/jobs/route.ts
+'use server';
+
+import { NextResponse } from 'next/server';
+
+export async function GET(request: Request) {
+  const API_SERVER = process.env.NEXT_PUBLIC_API_SERVER!;
+
+  try {
+    const response = await fetch(`${API_SERVER}/jobs`);
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error('Error from API server:', errorText);
+      return NextResponse.json({ error: 'Error fetching jobs' }, { status: 500 });
+    }
+    const result = await response.json();
+    return NextResponse.json(result, { status: 200 });
+  } catch (error) {
+    console.error('Error fetching jobs:', error);
+    return NextResponse.json({ error: 'Error fetching jobs' }, { status: 500 });
+  }
+}

src/app/api/fine-tune/jobs/route.ts

@@ -0,0 +1,53 @@
+// src/app/api/model/serve-base/route.ts
+'use server';
+
+import { NextResponse } from 'next/server';
+
+export async function POST() {
+  try {
+    console.log('Received serve-base model request');
+
+    const API_SERVER = process.env.NEXT_PUBLIC_API_SERVER!;
+    const endpoint = `${API_SERVER}/model/serve-base`;
+
+    console.log(`Forwarding request to the API server: ${endpoint}`);
+
+    // No request body needed for serving the base model
+    const response = await fetch(endpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' }
+    });
+
+    console.log('Response from API server (serve-base):', {
+      status: response.status,
+      statusText: response.statusText
+    });
+
+    if (!response.ok) {
+      console.error('Error response from the API server:', response.status, response.statusText);
+      return NextResponse.json({ error: 'Failed to serve the base model on the API server' }, { status: response.status });
+    }
+
+    // Parse response safely
+    let responseData;
+    try {
+      const text = await response.text();
+      responseData = text ? JSON.parse(text) : {};
+      console.log('Parsed response data (serve-base):', 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 for serve-base:', responseData);
+      return NextResponse.json({ error: 'API server response does not contain job_id' }, { status: 500 });
+    }
+
+    console.log('Returning success response with job_id (serve-base):', responseData.job_id);
+    return NextResponse.json(responseData, { status: 200 });
+  } catch (error) {
+    console.error('Unexpected error during serve-base:', error);
+    return NextResponse.json({ error: 'An unexpected error occurred during serving the base model' }, { status: 500 });
+  }
+}