DEV Community

Connie Leung
Connie Leung

Posted on • Updated on • Originally published at

Text translation using langchain.js and Gemini in a NestJS application


I am a language learner who learns Mandarin and Spanish in my spare time. When I discovered that text translation using langchain.js and Gemini 1.0 Pro is possible, I wanted to leverage the strength of generative AI in my hobby. Therefore, I built a NestJS application to translate texts between two languages through LangChain LLM and Gemini 1.0 Pro.

What is langchain.js?

Langchain is a framework for developing applications powered by language models. It offers libraries to create prompts, text embedding, retrievers, and chat models and integrate with third parties such as Google.

Generate Gemini API Key

Go to to generate an API key for a new or an existing Google Cloud project.

Create a new NestJS Project

nest new nestjs-genai-translation
Enter fullscreen mode Exit fullscreen mode

Install dependencies

npm i --save-exact  zod @nestjs/swagger @nestjs/throttler dotenv compression helmet langchain @langchain/google-genai
Enter fullscreen mode Exit fullscreen mode

Generate a Translation Module

nest g mo translation
nest g co translation/presenters/http/translator --flat
nest g s translation/application/langchainTranslator --flat
Enter fullscreen mode Exit fullscreen mode

Create a Translation module, a controller, and a service for the API.

Define Gemini environment variables

// .env.example

GOOGLE_GEMINI_API_KEY=<google gemini api key>
Enter fullscreen mode Exit fullscreen mode

Copy .env.example to .env, and replace GOOGLE_GEMINI_API_KEY and GOOGLE_GEMINI_MODEL with the actual API Key and the Gemini model name, respectively.

  • GOOGLE_GEMINI_API_KEY - Gemini API key of Gemini
  • GOOGLE_GEMINI_MODEL - Gemini mode name. In this application, I use Gemini 1.0 Pro to perform text translations
  • AI_SERVICE - Generative AI service to be used in the application

Add .env to the .gitignore file to prevent accidentally committing the Gemini API Key to the GitHub repo.

Add configuration files

The project has 3 configuration files. validate.config.ts validates the payload is valid before any request can route to the controller to execute.

// validate.config.ts

import { ValidationPipe } from '@nestjs/common';

export const validateConfig = new ValidationPipe({
  whitelist: true,
  stopAtFirstError: true,
  forbidUnknownValues: false,
Enter fullscreen mode Exit fullscreen mode

env.config.ts extracts the environment variables from process.env and stores the values in the env object.

// env.config.ts

import dotenv from 'dotenv';
import { Integration } from '~core/types/integration.type';


export const env = {
  PORT: parseInt(process.env.PORT || '3000'),
    API_KEY: process.env.GOOGLE_GEMINI_API_KEY || '',
    MODEL_NAME: process.env.GOOGLE_GEMINI_MODEL || 'gemini-pro',
  AI_SERVICE: (process.env.AI_SERVICE || 'langchain_googleChatModel') as Integration,
Enter fullscreen mode Exit fullscreen mode

throttler.config.ts defines the rate limit of the Translation API

// throttler.config.ts

import { ThrottlerModule } from '@nestjs/throttler';

export const throttlerConfig = ThrottlerModule.forRoot([
    ttl: 60000,
    limit: 10,
Enter fullscreen mode Exit fullscreen mode

Each route allows ten requests in 60,000 milliseconds or 1 minute.

Bootstrap the application

// bootstrap.ts

export class Bootstrap {
  private app: NestExpressApplication;

  async initApp() { = await NestFactory.create(AppModule);

  enableCors() {;

  setupMiddleware() {{ limit: '1000kb' }));{ extended: false }));;;

  setupGlobalPipe() {;

  async startApp() {

  setupSwagger() {
    const config = new DocumentBuilder()
      .setTitle('Generative AI Translator')
      .setDescription('Integrate with Generative AI to translate a text from one language to another language')
      .addTag('Azure OpenAI, Langchain, Gemini 1.0 Pro Model, Google Cloud Translation API')
    const document = SwaggerModule.createDocument(, config);
    SwaggerModule.setup('api',, document);
Enter fullscreen mode Exit fullscreen mode

Add a Bootstrap class to set up Swagger, middleware, global validation, cors, and finally, application start.

// main.ts

import { Bootstrap } from '~core/bootstrap';

async function bootstrap() {
  const bootstrap = new Bootstrap();
  await bootstrap.initApp();
  await bootstrap.startApp();
  .then(() => console.log('The application starts successfully'))
  .catch((error) => console.error(error));
Enter fullscreen mode Exit fullscreen mode

The bootstrap function enables CORS, registers middleware to the application, sets up Swagger documentation, and uses a global pipe to validate payloads.

I have laid down the groundwork and the next step is to add routes to receive payload to translate texts between source language and target language.

Define Translation DTO

// languages_codes.validation.ts

import { z } from 'zod';

  English: 'en',
  Spanish: 'es',
  'Simplified Chinese': 'zh-Hans',
  'Traditional Chinese': 'zh-Hant',
  Vietnamese: 'vi',
  Japanese: 'ja',
} as const;

export const ZOD_LANGUAGE_CODES = z.nativeEnum(LANGUAGE_CODES, {
  required_error: 'Language code is required',
  invalid_type_error: 'Language code is invalid',
export type LanguageCodesType = z.infer<typeof ZOD_LANGUAGE_CODES>;
Enter fullscreen mode Exit fullscreen mode
// translate-text.dto.ts

import { z } from 'zod';
import { ZOD_LANGUAGE_CODES } from '~translation/application/validations/language_codes.validation';

export const translateTextSchema = z
    text: z.string({
      required_error: 'Text is required',
    srcLanguageCode: ZOD_LANGUAGE_CODES,
    targetLanguageCode: ZOD_LANGUAGE_CODES,

export type TranslateTextDto = z.infer<typeof translateTextSchema>;
Enter fullscreen mode Exit fullscreen mode

translateTextSchema accepts a text, a source language code, and a target language code. Then, I use zod to infer the type of translateTextSchema and assign it to TranslateTextDto.

Define Translator Interface

This application is designed to translate texts using either Azure OpenAI, langchain.js, Gemini Pro Model, or Google Cloud Translation API. Therefore, I created a Translator interface, and all services that implement the interface must fulfill the contract.

//  translator-input.interface.ts

import { LanguageCodesType } from '../validations/language_codes.validation';

export interface TranslateInput {
  text: string;
  srcLanguageCode: LanguageCodesType;
  targetLanguageCode: LanguageCodesType;
Enter fullscreen mode Exit fullscreen mode
// translate-result.interface.ts

import { Integration } from '~core/types/integration.type';

export interface TranslationResult {
  text: string;
  aiService: Integration;
Enter fullscreen mode Exit fullscreen mode
// translator.interface.ts

import { TranslationResult } from './translation-result.interface';
import { TranslateInput } from './translator-input.interface';

export interface Translator {
  translate(input: TranslateInput): Promise<TranslationResult>;
Enter fullscreen mode Exit fullscreen mode

Implement Langchain Translator Service

// language_names.enum.ts

export enum LANGUAGE_NAMES {
  ENGLISH = 'English',
  JAPANESE = 'Japanese',
  SIMPLIFIED_CHINESE = 'Simplified Chinese',
  TRADITIONAL_CHINESE = 'Traditional Chinese',
  SPANISH = 'Spanish',
  VIETNAMESE = 'Vietnamese',
Enter fullscreen mode Exit fullscreen mode

LANGUAGE_NAMES enum represents the language names of the language codes. The prompt template of LangChain uses the language names to create a formatted prompt to query the Gemini 1.0 Pro model.

// translator.constant.ts

Enter fullscreen mode Exit fullscreen mode
// translation-chain.provider.ts

// Omit the import statments due to brevity

const chatModel = new ChatGoogleGenerativeAI({
  modelName: env.GEMINI.MODEL_NAME,
  maxOutputTokens: 128,
  safetySettings: [
      category: HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
      category: HarmCategory.HARM_CATEGORY_HARASSMENT,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
      category: HarmCategory.HARM_CATEGORY_HATE_SPEECH,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
      category: HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
      threshold: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
  temperature: 0,
  topK: 3,
  topP: 0.5,
  apiKey: env.GEMINI.API_KEY,

export const GEMINI_LLM_CHAIN_PROVIDER: Provider = {
  useFactory: () => {
    const systemMessageTemplate = SystemMessagePromptTemplate.fromTemplate(
      'You are a helpful language translator that translates {srcLanguageName} to {targetLanguageName}',
    const humanMessageTemplate = HumanMessagePromptTemplate.fromTemplate('{text}');
    const chatPrompt = ChatPromptTemplate.fromMessages([systemMessageTemplate, humanMessageTemplate]);

    const outputParser = new StringOutputParser();
    return chatPrompt.pipe(chatModel).pipe(outputParser);
Enter fullscreen mode Exit fullscreen mode

GEMINI_LLM_CHAIN_PROVIDER creates a provider that feeds the prompt to the chatbot of Gemini 1.0 Pro and outputs the string result.

// langchain-translator.service.ts

// Omit import statements for brevity

export class LangchainTranslatorService implements Translator {
  readonly languageMapper = new Map<LanguageCodesType, LANGUAGE_NAMES>();

  constructor(@Inject(GEMINI_CHAT_MODEL_LLM_CHAIN) private readonly llmChain: Runnable<any, string>) {
    this.languageMapper.set('en', LANGUAGE_NAMES.ENGLISH);
    this.languageMapper.set('es', LANGUAGE_NAMES.SPANISH);
    this.languageMapper.set('ja', LANGUAGE_NAMES.JAPANESE);
    this.languageMapper.set('vi', LANGUAGE_NAMES.VIETNAMESE);
    this.languageMapper.set('zh-Hans', LANGUAGE_NAMES.SIMPLIFIED_CHINESE);
    this.languageMapper.set('zh-Hant', LANGUAGE_NAMES.TRADITIONAL_CHINESE);

  async translate({ text, srcLanguageCode, targetLanguageCode }: TranslateInput): Promise<TranslationResult> {
    const srcLanguageName = this.languageMapper.get(srcLanguageCode);
    const targetLanguageName = this.languageMapper.get(targetLanguageCode);

    const translatedText = await this.llmChain.invoke({
      text: text,

    return {
      text: translatedText,
      aiService: 'langchain_googleChatModel',
Enter fullscreen mode Exit fullscreen mode

The translate method of LangchainTranslatorService uses the language codes to determine the source and target language names. Then, the language names and the text are passed to the LLM chain to obtain text translations. Finally, the method returns the translated text in the HTTP response.

Implement Translator Controller

// zod-validation.pipe.ts

export class ZodValidationPipe implements PipeTransform {
  constructor(private schema: ZodSchema) {}

  transform(value: unknown) {
    try {
      const parsedValue = this.schema.parse(value);
      return parsedValue;
    } catch (error) {
      if (error instanceof ZodError) {
        throw new BadRequestException(error.errors?.[0]?.message || 'Validation failed');
      } else if (error instanceof Error) {
        throw new BadRequestException(error.message);
      throw error;
Enter fullscreen mode Exit fullscreen mode

ZodValidationPipe is a pipe that validates the payload against the Zod schema. When the validation is successful, the payload will be parsed and returned. When the validation fails, the pipe intercepts the ZodError and returns an instance of BadRequestException.

// translator.controller.ts

// Omit the import statements to save space

export class TranslatorController {
  constructor(@Inject(TRANSLATOR) private translatorService: Translator) {}

    description: 'An intance of TranslatTextDto',
    required: true,
    schema: {
      type: 'object',
      properties: {
        text: {
          type: 'string',
          description: 'text to be translated',
        srcLanguageCode: {
          type: 'string',
          description: 'source language code',
          enum: ['en', 'es', 'zh-Hans', 'zh-Hant', 'vi', 'ja'],
        targetLanguageCode: {
          type: 'string',
          description: 'target language code',
          enum: ['en', 'es', 'zh-Hans', 'zh-Hant', 'vi', 'ja'],
    examples: {
      greeting: {
        value: {
          text: 'Good morning, good afternoon, good evening.',
          srcLanguageCode: 'en',
          targetLanguageCode: 'es',
    description: 'The translated text',
    schema: {
      type: 'object',
      properties: {
        text: { type: 'string', description: 'translated text' },
        aiService: { type: 'string', description: 'AI service' },
    status: 200,
  @UsePipes(new ZodValidationPipe(translateTextSchema))
  translate(@Body() dto: TranslateTextDto): Promise<TranslationResult> {
    return this.translatorService.translate(dto);
Enter fullscreen mode Exit fullscreen mode

The TranslatorController injects Translator that is an instance of LangchainTranslatorService. The endpoint invokes the translate method to perform text translation using langchain.js and Gemini 1.0 Pro model.

Dynamic registration

This application registers the translation service based on the AI_SERVICE environment variable. The value of the environment variable is one of azureOpenAI, langchain_googleChatModel, and google_translate.

// .env.example

Enter fullscreen mode Exit fullscreen mode
// integration.type.ts

export type Integration = 'azureOpenAI' | 'langchain_googleChatModel' | 'google_translate';
Enter fullscreen mode Exit fullscreen mode
// translator.module.ts

// Omit import statements for brevity

function createProviders(serviceType: Integration) {
  const serviceMap = new Map<Integration, any>();
  serviceMap.set('azureOpenAI', AzureTranslatorService);
  serviceMap.set('langchain_googleChatModel', LangchainTranslatorService);
  const translatorService = serviceMap.get(serviceType);

  const providers: Provider[] = [
      provide: TRANSLATOR,
      useClass: translatorService,

  if (serviceType === 'langchain_googleChatModel') {
  return providers;

  imports: [HttpModule],
  controllers: [TranslatorController],
export class TranslationModule {
  static register(type: Integration = 'azureOpenAI'): DynamicModule {
    const logger = new Logger(;
    const isProduction = env.APP_ENV === APP_ENV_NAMES.PRODUCTION;
    // google_translation works in local environment. Default to azureOpenAI in production
    const serviceType = isProduction && type === 'google_translate' ? 'azureOpenAI' : type;

    logger.log(`isProduction? ${isProduction}`);
    logger.log(`serviceType? ${serviceType}`);

    return {
      module: TranslationModule,
      providers: createProviders(serviceType),
Enter fullscreen mode Exit fullscreen mode

In TranslationModule, I define a register method that returns a DynamicModule. When type is langchain_googleChatModel, the TRANSLATOR token provides LangchainTranslatorService. Next, TranslationModule.register(env.AI_SERVICE) creates a TranslationModule that I import in the AppModule.

// app.module.ts

  imports: [throttlerConfig, TranslationModule.register(env.AI_SERVICE)],
  controllers: [AppController],
  providers: [
      provide: APP_GUARD,
      useClass: ThrottlerGuard,
export class AppModule {}
Enter fullscreen mode Exit fullscreen mode

Test the endpoints

I can test the endpoints with cURL, Postman or Swagger documentation after launching the application.

npm run start:dev
Enter fullscreen mode Exit fullscreen mode

The URL of the Swagger documentation is http://localhost:3000/api.


curl --location 'http://localhost:3000/translator' \
--header 'Content-Type: application/json' \
--data '{
    "text": "My name is John\n\nI am a Chinese",
    "srcLanguageCode": "en",
    "targetLanguageCode": "es"
Enter fullscreen mode Exit fullscreen mode

This is the end of my blog post that uses langchain.js and Gemini 1.0 Pro to solve a real-world problem. I only scratched the surface of LangChain LLM and LangChain has many resources to solve problems in different domains

Dockerize the application

// .dockerignore

Enter fullscreen mode Exit fullscreen mode

Create a .dockerignore file for Docker to ignore some files and directories.

// Dockerfile

# Use an official Node.js runtime as the base image
FROM node:20-alpine

# Set the working directory in the container

# Copy package.json and package-lock.json to the working directory
COPY package*.json tsconfig.json ./

# Install the dependencies
RUN npm install

RUN npm run build

# Copy the rest of the application code to the working directory
COPY . .

# Expose a port (if your application listens on a specific port)

# Define the command to run your application
CMD [ "npm", "start" ]
Enter fullscreen mode Exit fullscreen mode

I added the Dockerfile that installs the dependencies, builds the NestJS application, and starts it at port 3000.

//  .env.docker.example

APP_ENV=<application environment>
AZURE_OPENAI_TRANSLATOR_URL=<translator url>/translate
GOOGLE_GEMINI_API_KEY=<google gemini api key>
Enter fullscreen mode Exit fullscreen mode

.env.docker.example stores the relevant environment variables that I copied from the NestJS application.

// docker-compose.yaml

version: '3.8'

      context: ./nestjs-genai-translation
      dockerfile: Dockerfile
      - PORT=${PORT}
      - APP_ENV=${APP_ENV}
      - "${PORT}:${PORT}"
      - ai
    restart: always

Enter fullscreen mode Exit fullscreen mode

I added the docker-compose.yaml in the root folder, which was responsible for creating the NestJS application container.

This concludes my blog post about using langchain.js and Gemini 1.0 Pro model to solve a real-world problem. I only scratched the surface of LangChain LLM, and LangLang supports many integrations to solve problems in different domains. I hope you like the content and continue to follow my learning experience in Angular, NestJS, and other technologies.


Top comments (0)