Merge pull request #1 from glaucia86/GL/migration-to-langchainjs-v2

feat: Migration to LangChain.js

Author: glaucia86

package-lock.json

@@ -10,11 +10,14 @@
   },
   "dependencies": {
     "@heroicons/react": "^2.2.0",
+    "@langchain/core": "^0.3.62",
+    "@langchain/openai": "^0.5.18",
     "dotenv": "^16.5.0",
+    "langchain": "^0.3.29",
     "next": "15.3.4",
-    "openai": "^5.6.0",
     "react": "^19.0.0",
-    "react-dom": "^19.0.0"
+    "react-dom": "^19.0.0",
+    "zod": "^3.25.76"
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3",

package.json

@@ -1,5 +1,6 @@
 import { NextRequest, NextResponse } from 'next/server';
-import { getGitHubModelsService } from '../../../lib/services/github-models.services'
+//import { getGitHubModelsService } from '../../../lib/services/github-models.services'
+import { getLangChainMicroblogService } from '@/lib/services/langchain.factory';
 import type { GenerateApiRequest, GenerateApiResponse } from '@/types';
 
 // Rate limiting configuration
@@ -10,114 +11,123 @@ const requestCounts = new Map<string, { count: number; resetTime: number }>();
 // Input validation
 function validateRequest(body: any): GenerateApiRequest | null {
   const { topic, tone, keywords } = body;
-  
+
   if (!topic || typeof topic !== 'string') {
     return null;
   }
-  
+
   if (!tone || typeof tone !== 'string') {
     return null;
   }
-  
+
   if (keywords !== undefined && typeof keywords !== 'string') {
     return null;
   }
-  
+
   return { topic: topic.trim(), tone: tone.toLowerCase(), keywords: keywords?.trim() };
 }
 
 // Rate limiting implementation
 function checkRateLimit(clientId: string): boolean {
   const now = Date.now();
   const clientData = requestCounts.get(clientId);
-  
+
   if (!clientData || now > clientData.resetTime) {
     requestCounts.set(clientId, {
       count: 1,
       resetTime: now + RATE_LIMIT_WINDOW,
     });
     return true;
   }
-  
+
   if (clientData.count >= MAX_REQUESTS_PER_WINDOW) {
     return false;
   }
-  
+
   clientData.count += 1;
   return true;
 }
 
 export async function POST(request: NextRequest) {
   try {
     // Extract client identifier (IP or session)
-    const clientId = request.headers.get('x-forwarded-for') || 
-                    request.headers.get('x-real-ip') || 
-                    'anonymous';
-    
+    const clientId = request.headers.get('x-forwarded-for') ||
+      request.headers.get('x-real-ip') ||
+      'anonymous';
+
     // Check rate limit
     if (!checkRateLimit(clientId)) {
       return NextResponse.json(
         { success: false, error: 'Rate limit exceeded. Please try again later.' },
         { status: 429 }
       );
     }
-    
+
     // Parse and validate request body
     const body = await request.json();
     const validatedData = validateRequest(body);
-    
+
     if (!validatedData) {
       return NextResponse.json(
         { success: false, error: 'Invalid request data' },
         { status: 400 }
       );
     }
-    
+
     // Additional validation
     if (validatedData.topic.length < 10 || validatedData.topic.length > 280) {
       return NextResponse.json(
         { success: false, error: 'Topic must be between 10 and 280 characters' },
         { status: 400 }
       );
     }
-    
+
     const validTones = ['technical', 'casual', 'motivational'];
     if (!validTones.includes(validatedData.tone)) {
       return NextResponse.json(
         { success: false, error: 'Invalid tone of voice' },
         { status: 400 }
       );
     }
-    
+
     // Generate content using the service
-    const service = getGitHubModelsService();
+    const service = getLangChainMicroblogService({
+      enableLogging: process.env.NODE_ENV === 'development',
+      enableRetry: true,
+      customRetryConfig: {
+        maxAttempts: 3,
+        baseDelayMs: 1000
+      }
+    });
+
     const generatedContent = await service.generateMicroblogContent(
       validatedData.topic,
       validatedData.tone,
       validatedData.keywords
     );
-    
+
     // Return successful response
     const response: GenerateApiResponse = {
       success: true,
       content: generatedContent,
     };
-    
+
     return NextResponse.json(response, {
       status: 200,
       headers: {
         'Cache-Control': 'no-store, max-age=0',
         'Content-Type': 'application/json',
+        'X-Service-Used': 'langchain'
       },
     });
-    
+
   } catch (error) {
-    console.error('Generation API error:', error);
-    
+    console.error('LangChain Generation API error:', error);
+
     // Determine error type and status code
     let statusCode = 500;
     let errorMessage = 'An unexpected error occurred';
-    
+
     if (error instanceof Error) {
       if (error.message.includes('environment variables')) {
         statusCode = 500;
@@ -128,26 +138,45 @@ export async function POST(request: NextRequest) {
       } else if (error.message.includes('Invalid')) {
         statusCode = 400;
         errorMessage = error.message;
+      } else if (error.message.includes('LangChain')) {
+        statusCode = 500;
+        errorMessage = 'AI service temporarily unavailable'
       } else {
         errorMessage = 'Failed to generate content';
       }
     }
-    
+
     return NextResponse.json(
-      { success: false, error: errorMessage },
+      { success: false, error: errorMessage, service: 'langchain' },
       { status: statusCode }
     );
   }
 }
 
 // Health check endpoint
 export async function GET() {
-  return NextResponse.json(
-    { 
+
+  try {
+    const service = getLangChainMicroblogService();
+    const testResult = await service.testConnection();
+
+    return NextResponse.json(
+    {
       status: 'healthy',
-      service: 'generate-api',
+      service: 'langchain-generate-api',
+      timestamp: new Date().toISOString(),
+      connectivity: {
+        success: testResult.success,
+        latency: testResult.latency,
+        model: testResult.model
+      }
+    });
+  } catch (error) {
+    return NextResponse.json({
+      status: 'unhealthy',
+      service: 'langchain-generate-api',
       timestamp: new Date().toISOString(),
-    },
-    { status: 200 }
-  );
+      error: error instanceof Error ? error.message : 'Unknown error'
+    }, { status: 503 })
+  }
 }

src/app/api/generate/route.ts

@@ -0,0 +1,68 @@
+import { NextResponse } from 'next/server';
+import { LangChainService } from '../../../lib/services/langchain.factory';
+import { ServiceMigrator } from '../../../lib/services/migration/service.migrator';
+
+export async function GET() {
+  try {
+    const factoryInfo = LangChainService.info();
+    
+    return NextResponse.json({
+      migration: {
+        status: 'completed',
+        usingLangChain: ServiceMigrator.isUsingLangChain(),
+        timestamp: new Date().toISOString()
+      },
+      factory: factoryInfo,
+      environment: {
+        nodeEnv: process.env.NODE_ENV,
+        hasGitHubToken: !!process.env.NEXT_PUBLIC_GITHUB_MODELS_TOKEN,
+        endpoint: process.env.NEXT_PUBLIC_GITHUB_MODELS_ENDPOINT
+      },
+      health: factoryInfo.hasInstance ? {
+        metrics: factoryInfo.metrics,
+        config: factoryInfo.config
+      } : null
+    });
+  } catch (error) {
+    return NextResponse.json({
+      migration: {
+        status: 'error',
+        error: error instanceof Error ? error.message : 'Unknown error'
+      }
+    }, { status: 500 });
+  }
+}
+
+export async function POST(request: Request) {
+  try {
+    const { action } = await request.json();
+    
+    switch (action) {
+      case 'enable-langchain':
+        ServiceMigrator.enableLangChain();
+        break;
+      case 'disable-langchain':
+        ServiceMigrator.disableLangChain();
+        break;
+      case 'reset-factory':
+        LangChainService.reset();
+        break;
+      case 'reset-metrics':
+        const service = LangChainService.development();
+        service.resetMetrics();
+        break;
+      default:
+        throw new Error('Invalid action');
+    }
+    
+    return NextResponse.json({
+      success: true,
+      message: `Action '${action}' completed successfully`
+    });
+  } catch (error) {
+    return NextResponse.json({
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error'
+    }, { status: 400 });
+  }
+}