feat: pinecone chat

Author: AlexBarciaJS

apps/nest-api/package.json

@@ -50,7 +50,9 @@
     "@langchain/core": "^0.3.42",
     "@langchain/ollama": "^0.2.0",
     "@langchain/openai": "^0.4.4",
+    "@langchain/pinecone": "^0.2.0",
     "@nestjs/config": "^4.0.1",
-    "@nestjs/swagger": "^11.0.6"
+    "@nestjs/swagger": "^11.0.6",
+    "@pinecone-database/pinecone": "^5.1.1"
   }
 }

apps/nest-api/src/app/app.module.ts

@@ -1,15 +1,13 @@
 import { Module } from '@nestjs/common';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
-import { ChatCoreModule } from './chat-core/chat-core.module';
 import { ConfigModule } from '@nestjs/config';
-import { ChatGeneralModule } from './chat-general/chat-general.module';
+import { PineconeDbModule } from './pinecone-db/pinecone-db.module';
 
 @Module({
   imports: [
     ConfigModule.forRoot({ isGlobal: true }),
-    ChatCoreModule,
-    ChatGeneralModule
+    PineconeDbModule,
   ],
   controllers: [AppController],
   providers: [AppService],

apps/nest-api/src/app/chat-general/controller/chat-general.controller.ts

@@ -1,11 +1,16 @@
 import { Body, Controller, Post } from '@nestjs/common';
+import { ApiBody, ApiTags } from '@nestjs/swagger';
 import { ChatGeneralService } from '../service/chat-general.service';
 
+@ApiTags('chat')
 @Controller('chat')
 export class ChatGeneralController {
   constructor(private chatGeneralService: ChatGeneralService) {}
 
   @Post('question')
+  @ApiBody({
+    schema: { type: 'object', properties: { question: { type: 'string' } } },
+  })
   askQuestion(@Body('question') question: string) {
     return this.chatGeneralService.askQuestionLlama3(question);
   }

apps/nest-api/src/app/pinecone-db/controller/pinecone-db.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { PineconeDbController } from './pinecone-db.controller';
+
+describe('PineconeDbController', () => {
+  let controller: PineconeDbController;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [PineconeDbController],
+    }).compile();
+
+    controller = module.get<PineconeDbController>(PineconeDbController);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

apps/nest-api/src/app/pinecone-db/controller/pinecone-db.controller.ts

@@ -0,0 +1,54 @@
+import { Body, Controller, Get, Post } from '@nestjs/common';
+import { ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { PineconeDbService } from '../service/pinecone-db.service';
+import { ChatModel } from '../../enums/chat-model';
+
+interface CustomBody {
+  question: string;
+  index: string;
+  model: ChatModel;
+}
+
+@ApiTags('pinecone')
+@Controller('pinecone')
+export class PineconeDbController {
+  constructor(private readonly pineconeDbService: PineconeDbService) {}
+
+  @Post('question')
+  @ApiOperation({ summary: 'Ask a question to Pinecone DB' })
+  @ApiBody({
+    schema: { type: 'object', properties: { question: { type: 'string' } } },
+  })
+  @ApiResponse({ status: 200, description: 'Successful response' })
+  askToPineconeDb(@Body('question') question: string) {
+    return this.pineconeDbService.askToPineconeDb(question);
+  }
+
+  @Post('custom')
+  @ApiOperation({ summary: 'Ask a question to Pinecone DB by index' })
+  @ApiBody({
+    schema: {
+      type: 'object',
+      properties: {
+        question: { type: 'string' },
+        index: { type: 'string' },
+        model: { type: 'string', enum: Object.values(ChatModel) },
+      },
+    },
+  })
+  @ApiResponse({ status: 200, description: 'Successful response' })
+  askToPineconeByIndex(@Body() customBody: CustomBody) {
+    return this.pineconeDbService.askToPineconeDb(
+      customBody.question,
+      customBody.index,
+      customBody.model,
+    );
+  }
+
+  @Get('indexes')
+  @ApiOperation({ summary: 'Get Pinecone indexes' })
+  @ApiResponse({ status: 200, description: 'Successful response' })
+  pineconeIndexes() {
+    return this.pineconeDbService.pineconeIndexes();
+  }
+}

apps/nest-api/src/app/pinecone-db/pinecone-db.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { PineconeDbController } from './controller/pinecone-db.controller';
+import { PineconeDbService } from './service/pinecone-db.service';
+import { ChatCoreModule } from '../chat-core/chat-core.module';
+
+@Module({
+  imports: [ChatCoreModule],
+  controllers: [PineconeDbController],
+  providers: [PineconeDbService],
+})
+export class PineconeDbModule {}

apps/nest-api/src/app/pinecone-db/service/pinecone-db.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { PineconeDbService } from './pinecone-db.service';
+
+describe('PineconeDbService', () => {
+  let service: PineconeDbService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [PineconeDbService],
+    }).compile();
+
+    service = module.get<PineconeDbService>(PineconeDbService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

apps/nest-api/src/app/pinecone-db/service/pinecone-db.service.ts

@@ -0,0 +1,90 @@
+import { Injectable } from '@nestjs/common';
+import { Pinecone as PineconeClient } from '@pinecone-database/pinecone';
+import { PineconeStore } from '@langchain/pinecone';
+import { OpenAIEmbeddings } from '@langchain/openai';
+import { DocumentInterface } from '@langchain/core/documents';
+import { HumanMessage } from '@langchain/core/messages';
+import { ChatProvider } from '../../chat-core/provider';
+import { ChatModel } from '../../enums/chat-model';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class PineconeDbService {
+  private readonly CHAT_GPT_EMBEDDING_MODEL: string;
+  private readonly PINECONE_INDEX: string;
+
+  constructor(
+    private configService: ConfigService,
+    private chatProvider: ChatProvider,
+  ) {
+    this.CHAT_GPT_EMBEDDING_MODEL =
+      this.configService.get<string>('CHAT_GPT_EMBEDDING_MODEL') ||
+      'default_model';
+
+    this.PINECONE_INDEX =
+      this.configService.get<string>('PINECONE_INDEX') || 'default_index';
+  }
+
+  async askToPineconeDb(
+    question: string,
+    customIndex?: string,
+    model?: ChatModel,
+  ) {
+    const embeddings = new OpenAIEmbeddings({
+      model: this.CHAT_GPT_EMBEDDING_MODEL,
+    });
+
+    const pinecone = new PineconeClient();
+    const index = pinecone.Index(customIndex || this.PINECONE_INDEX);
+
+    const vectorStore = await PineconeStore.fromExistingIndex(embeddings, {
+      pineconeIndex: index,
+      maxConcurrency: 5,
+    });
+
+    //query
+    const documents = await vectorStore.similaritySearch(question, 2);
+    // retorna solamente las 100 primeras palabras de cada documento
+    console.log(
+      'docuemnts',
+      documents.map((doc) => doc.pageContent.slice(0, 100)),
+    );
+    return this.getExactlyAnswer(documents, question, model);
+  }
+
+  async pineconeIndexes() {
+    const pinecone = new PineconeClient();
+    const indexes = await pinecone.listIndexes();
+    return indexes.indexes;
+  }
+
+  getExactlyAnswer(
+    documents: DocumentInterface[],
+    question: string,
+    model?: ChatModel,
+  ) {
+    const humanMessages: HumanMessage[] = [];
+    for (const document of documents) {
+      const message = new HumanMessage({
+        content: [
+          {
+            type: 'text',
+            text: document.pageContent,
+          },
+        ],
+      });
+
+      humanMessages.push(message);
+    }
+
+    if (model) {
+      return this.chatProvider.askQuestionByModel(
+        question,
+        model,
+        humanMessages,
+      );
+    }
+
+    return this.chatProvider.askQuestion(question, humanMessages);
+  }
+}

apps/nest-api/src/main.ts

@@ -6,12 +6,34 @@
 import { Logger } from '@nestjs/common';
 import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app/app.module';
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
   const globalPrefix = 'api';
   app.setGlobalPrefix(globalPrefix);
   const port = process.env.PORT || 3000;
+
+
+  app.enableCors({
+    origin: '*', // Permitir cualquier origen (puedes restringirlo a un dominio específico)
+    methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
+    allowedHeaders: 'Content-Type, Authorization',
+  });
+
+  // Swagger
+  const config = new DocumentBuilder()
+    .setTitle('API REST con NestJS')
+    .setDescription('Documentación de la API usando Swagger')
+    .setVersion('1.0')
+    .addTag('chats')
+    .build();
+
+  const document = SwaggerModule.createDocument(app, config);
+  SwaggerModule.setup('api', app, document);
+
+
+
   await app.listen(port);
   Logger.log(
     `🚀 Application is running on: http://localhost:${port}/${globalPrefix}`

package.json

@@ -55,9 +55,12 @@
     "@nestjs/common": "^10.0.2",
     "@nestjs/core": "^10.0.2",
     "@nestjs/platform-express": "^10.0.2",
+    "@nestjs/swagger": "^11.0.6",
+    "@pinecone-database/pinecone": "^5.1.1",
     "axios": "^1.6.0",
     "reflect-metadata": "^0.1.13",
     "rxjs": "^7.8.0",
+    "swagger-ui-express": "^5.0.1",
     "vue": "^3.3.4",
     "vue-router": "^4.2.4"
   }