second base

src/app/api/embeddings/route.ts

@@ -0,0 +1,54 @@
+import { NextResponse } from 'next/server'
+import { generateEmbedding } from '@/lib/huggingface'
+import { createServerSupabaseClient } from '@/lib/supabase-server'
+
+export async function POST(request: Request) {
+  try {
+    const { content, title, metadata } = await request.json()
+
+    if (!content) {
+      return NextResponse.json(
+        { error: 'Content is required' },
+        { status: 400 }
+      )
+    }
+
+    // Generate embedding using Hugging Face
+    const embedding = await generateEmbedding(content)
+
+    // Store in Supabase with embedding
+    const supabase = await createServerSupabaseClient()
+    const { data, error } = await supabase
+      .from('documents')
+      .insert({
+        content,
+        title: title || null,
+        embedding,
+        metadata: metadata || {},
+      })
+      .select()
+      .single()
+
+    if (error) {
+      console.error('Supabase error:', error)
+      throw error
+    }
+
+    return NextResponse.json({ 
+      success: true, 
+      document: data 
+    }, { status: 200 })
+
+  } catch (error: unknown) {
+    console.error("Embedding API Error:", error);
+  
+    const message =
+      error instanceof Error ? error.message : "Internal server error";
+  
+    return NextResponse.json(
+      { error: message },
+      { status: 500 }
+    );
+  }
+
+}

src/app/api/search/route.ts

@@ -0,0 +1,57 @@
+import { NextResponse } from 'next/server'
+import { generateEmbedding } from '@/lib/huggingface'
+import { createServerSupabaseClient } from '@/lib/supabase-server'
+import type { VectorSearchRequest, VectorSearchResult } from '@/types'
+
+export async function POST(request: Request) {
+  try {
+    const body: VectorSearchRequest = await request.json()
+    const { 
+      query, 
+      match_threshold = 0.5, 
+      match_count = 5 
+    } = body
+
+    if (!query) {
+      return NextResponse.json(
+        { error: 'Query is required' },
+        { status: 400 }
+      )
+    }
+
+    console.log('Generating embedding for query:', query)
+    const queryEmbedding = await generateEmbedding(query)
+    console.log('Embedding generated, length:', queryEmbedding.length)
+
+    const supabase = await createServerSupabaseClient()
+    
+    console.log('Calling match_documents RPC...')
+    const { data, error } = await supabase.rpc('match_documents', {
+      query_embedding: queryEmbedding,
+      match_threshold,
+      match_count,
+    })
+
+    if (error) {
+      console.error('Search error:', error)
+      throw error
+    }
+
+    console.log('Search results:', data)
+    return NextResponse.json({ 
+      results: data as VectorSearchResult[] 
+    }, { status: 200 })
+
+  } catch (error: unknown) {
+    console.error("Search API Error:", error);
+  
+    const message =
+      error instanceof Error ? error.message : "Internal server error";
+  
+    return NextResponse.json(
+      { error: message },
+      { status: 500 }
+    );
+  }
+
+}

src/lib/huggingface.ts

@@ -1,53 +1,63 @@
-import { HfInference } from '@huggingface/inference'
-
-// Initialize Hugging Face client
-const hf = new HfInference(process.env.HUGGING_FACE_API_TOKEN)
-
-export async function runInference(
-  modelId: string,
-  inputs: any,
-  parameters?: Record<string, any>
-) {
-  try {
-    const response = await hf.textGeneration({
-      model: modelId,
-      inputs: inputs,
-      parameters: {
-        max_new_tokens: 250,
-        temperature: 0.7,
-        ...parameters,
-      },
-    })
-    
-    return response
-  } catch (error) {
-    console.error('Hugging Face Inference Error:', error)
-    throw error
-  }
-}
-
-// For custom inference endpoints
-export async function runCustomEndpoint(
-  endpointUrl: string,
-  inputs: any
-) {
-  try {
-    const response = await fetch(endpointUrl, {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${process.env.HUGGING_FACE_API_TOKEN}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({ inputs }),
-    })
-
-    if (!response.ok) {
-      throw new Error(`Endpoint error: ${response.statusText}`)
-    }
-
-    return await response.json()
-  } catch (error) {
-    console.error('Custom Endpoint Error:', error)
-    throw error
-  }
-}
+import { InferenceClient } from "@huggingface/inference";
+
+const apiKey = process.env.HUGGING_FACE_API_TOKEN;
+
+if (!apiKey) {
+  throw new Error("Missing HUGGING_FACE_API_TOKEN environment variable.");
+}
+
+const hf = new InferenceClient(apiKey);
+
+// Generate text embeddings
+export async function generateEmbedding(text: string): Promise<number[]> {
+  try {
+    const raw = await hf.featureExtraction({
+      model: "sentence-transformers/all-MiniLM-L6-v2",
+      inputs: text,
+    });
+
+    // Normalize HuggingFace outputs into flat number[]
+    if (typeof raw === "number") {
+      return [raw];
+    }
+
+    if (Array.isArray(raw)) {
+      // raw could be number[] OR number[][]
+      if (typeof raw[0] === "number") {
+        return raw as number[];
+      }
+
+      // number[][] → flatten
+      return (raw as number[][]).flat();
+    }
+
+    throw new Error("Unexpected embedding format from HuggingFace.");
+  } catch (error: unknown) {
+    console.error("Embedding generation error:", error);
+    throw error;
+  }
+}
+
+// Text generation
+export async function runInference(
+  modelId: string,
+  inputs: string,
+  parameters?: Record<string, unknown>,
+) {
+  try {
+    const response = await hf.textGeneration({
+      model: modelId,
+      inputs,
+      parameters: {
+        max_new_tokens: 250,
+        temperature: 0.7,
+        ...parameters,
+      },
+    });
+
+    return response;
+  } catch (error: unknown) {
+    console.error("Hugging Face Inference Error:", error);
+    throw error;
+  }
+}

src/lib/supabase.ts

@@ -1,8 +1,28 @@
-import { createBrowserClient } from '@supabase/ssr'
+import { createServerClient } from '@supabase/ssr'
+import { cookies } from 'next/headers'
 
-export function createClient() {
-  return createBrowserClient(
+export async function createServerSupabaseClient() {
+  const cookieStore = await cookies()
+
+  return createServerClient(
     process.env.NEXT_PUBLIC_SUPABASE_URL!,
-    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
+    process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
+    {
+      db: {
+        schema: 'public', // ← Explicitly set schema
+      },
+      cookies: {
+        getAll() {
+          return cookieStore.getAll()
+        },
+        setAll(cookiesToSet) {
+          try {
+            cookiesToSet.forEach(({ name, value, options }) =>
+              cookieStore.set(name, value, options)
+            )
+          } catch {}
+        },
+      },
+    }
   )
 }

src/types/index.ts

@@ -1,4 +1,4 @@
-// Database types
+// Existing types
 export interface ModelInteraction {
   id: string;
   user_input: string;
@@ -7,25 +7,40 @@ export interface ModelInteraction {
   created_at: string;
 }
 
-// API request/response types
+// More precise: inputs should be text for text-generation
 export interface InferenceRequest {
   model: string;
-  inputs: string | any;
-  parameters?: Record<string, any>;
+  inputs: string;
+  parameters?: Record<string, unknown>;
 }
 
-export interface InferenceResponse {
-  result: any;
+// Model responses are usually structured JSON
+export interface InferenceResponse<T = unknown> {
+  result: T;
   data?: ModelInteraction;
 }
 
-// Hugging Face types
-export interface HFModelConfig {
-  modelId: string;
-  endpoint?: string;
-  parameters?: {
-    max_new_tokens?: number;
-    temperature?: number;
-    top_p?: number;
-  };
+// NEW: Vector search types
+export interface Document {
+  id: string;
+  content: string;
+  title?: string;
+  embedding?: number[];
+  metadata?: Record<string, unknown>;
+  created_at: string;
+  updated_at?: string;
+}
+
+export interface VectorSearchRequest {
+  query: string;
+  match_threshold?: number;
+  match_count?: number;
+}
+
+export interface VectorSearchResult {
+  id: string;
+  content: string;
+  title?: string;
+  metadata?: Record<string, unknown>;
+  similarity: number;
 }

test-vector.ts

@@ -0,0 +1,34 @@
+async function testAddDocument() {
+  const response = await fetch('http://localhost:3000/api/embeddings', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      content: 'Next.js is a React framework for building web applications.',
+      title: 'Next.js Introduction',
+      metadata: { category: 'web development' }
+    })
+  })
+
+  const result = await response.json()
+  console.log('Document added:', result)
+}
+
+async function testSearch() {
+  const response = await fetch('http://localhost:3000/api/search', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      query: 'What is Next.js?',
+      match_threshold: 0.5,
+      match_count: 3
+    })
+  })
+
+  const result = await response.json()
+  console.log('Search results:', result)
+}
+
+// Run tests
+testAddDocument()
+  .then(() => testSearch())
+  .catch(console.error)