Introdução: Revolucione suas Descrições de Produto com IA

Em um mercado digital cada vez mais competitivo, descrições de produtos envolventes e persuasivas podem ser o diferencial entre uma conversão e um abandono de carrinho. Mas como criar centenas de descrições atraentes de forma eficiente?

A resposta está na combinação estratégica de NestJS (um framework Node.js robusto) com a tecnologia de IA Generativa do Google Gemini. Neste guia prático, vou mostrar como construir uma API profissional que transforma descrições básicas em conteúdo de marketing convincente em apenas 10 minutos.

O Que Você Vai Aprender

Ao final deste tutorial, você terá construído:

• Uma API RESTful completa usando NestJS
• Integração com Google Gemini AI para geração de conteúdo
• Validação robusta de dados usando decoradores
• Sistema de tratamento de erros profissional
• Implementação totalmente tipada com TypeScript

Pré-requisito: Conhecimento básico de TypeScript, Node.js e conceitos de API REST.

---

Preparando o Ambiente de Desenvolvimento

Requisitos Técnicos

Para seguir este tutorial, você precisará:

• Node.js (v18 ou superior)
• npm ou yarn como gerenciador de pacotes
• IDE como VS Code
• Conta no Google Cloud (para acesso à API Gemini)

Configurando o Acesso à API do Google Gemini

1. Acesse o Google AI Studio
2. Crie um novo projeto ou selecione um existente
3. Gere uma chave de API para o Gemini
4. Reserve esta chave para uso posterior

Instalação e Configuração Inicial

Vamos começar criando nosso projeto NestJS e instalando as dependências necessárias:

Crie um novo projeto NestJS (ou use um existente)

npm i -g @nestjs/cli
nest new api-gemini-nestjs

cd api-gemini-nestjs
npm install
npm install @google/generative-ai class-validator class-transformer @nestjs/config

Detalhamento das Dependências

• @google/generative-ai: SDK oficial do Google Gemini AI
• class-validator: Biblioteca para validação de dados usando decoradores
• class-transformer: Ferramenta para transformação e serialização de objetos
• @nestjs/config: Módulo para gerenciamento de variáveis de ambiente

Arquitetura do Projeto

Para manter nosso código organizado e escalável, seguiremos a estrutura de pastas recomendada pelo NestJS:

src/
├── products/
│   ├── dto/
│   │   └── create-product.dto.ts       # Objetos de Transferência de Dados
│   ├── interfaces/
│   │   └── product.interface.ts        # Interfaces TypeScript
│   ├── products.controller.ts          # Endpoints da API REST
│   ├── products.service.ts             # Lógica de negócios
│   └── products.module.ts              # Definição do módulo
├── gemini/
│   └── gemini.service.ts               # Integração com IA do Google
├── app.module.ts                       # Módulo principal da aplicação
└── main.ts                             # Ponto de entrada da aplicação

---

Acelere a sua carreira na Programação com IA

Se você é Programador e quer descobrir o plano exato para integrar IA no seu trabalho, construir um portfólio que impressiona… e ganhar R$5.000+ a mais com projetos exclusivos, conheça o Programa Code & IA.

---

Configuração das Variáveis de Ambiente

Vamos criar arquivos de ambiente para manter nossas configurações seguras:

# Configuração da API do Google Gemini
GEMINI_API_KEY=sua_chave_api_gemini_aqui

# Configuração da Aplicação
PORT=3000

Implementação Passo a Passo

1. Criando os Modelos de Dados

Primeiro, definiremos a interface do produto e o DTO (Data Transfer Object) para validação:

Interface do Produto (src/products/interfaces/product.interface.ts)

export interface Product {
  name: string;
  description: string;
  price: number;
  enhancedDescription?: string;
}

DTO de Criação de Produto (src/products/dto/create-product.dto.ts)

import { IsString, IsNumber, IsNotEmpty, Min } from 'class-validator';
import { Transform } from 'class-transformer';

export class CreateProductDto {
  @IsString()
  @IsNotEmpty()
  name: string;

  @IsString()
  @IsNotEmpty()
  description: string;

  @IsNumber()
  @Min(0)
  @Transform(({ value }) => parseFloat(value as string))
  price: number;
}

2. Implementando o Serviço de IA Gemini

Agora, vamos criar o serviço que se conectará à API do Google Gemini para aprimorar nossas descrições:

Serviço Gemini (src/gemini/gemini.service.ts)

import { Injectable, Logger } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import { GoogleGenerativeAI } from '@google/generative-ai';

@Injectable()
export class GeminiService {
  private readonly logger = new Logger(GeminiService.name);
  private genAI: GoogleGenerativeAI;

  constructor(private configService: ConfigService) {
    const apiKey = this.configService.get<string>('GEMINI_API_KEY');
    if (!apiKey) {
      throw new Error('GEMINI_API_KEY não está configurada');
    }
    this.genAI = new GoogleGenerativeAI(apiKey);
  }

  async enhanceProductDescription(
    name: string,
    description: string,
    price: number,
  ): Promise<string> {
    try {
      const model = this.genAI.getGenerativeModel({ model: 'gemini-2.5-flash' });

      const prompt = `
        Crie uma descrição aprimorada e focada em marketing para o seguinte produto:

        Nome do Produto: ${name}
        Descrição Original: ${description}
        Preço: R$${price}

        Por favor, crie uma descrição de produto persuasiva que:
        - Destaque os principais recursos e benefícios
        - Utilize linguagem de marketing persuasiva
        - Mantenha a precisão em relação à descrição original
        - Seja adequada para e-commerce
        - Tenha aproximadamente 2-3 frases

        Retorne apenas a descrição aprimorada, sem textos ou formatações adicionais.
      `;

      const result = await model.generateContent(prompt);
      const response = result.response;
      const text = response.text();

      this.logger.log(`Descrição aprimorada gerada para o produto: ${name}`);
      return text.trim();
    } catch (error) {
      this.logger.error(
        `Falha ao aprimorar descrição para o produto: ${name}`,
        error instanceof Error ? error.stack : String(error),
      );
      throw new Error('Falha ao gerar descrição aprimorada');
    }
  }
}

3. Criando o Serviço de Produtos

O próximo passo é criar o serviço de produtos que utilizará o serviço Gemini:

Serviço de Produtos (src/products/products.service.ts)

import { Injectable, Logger } from '@nestjs/common';
import { CreateProductDto } from './dto/create-product.dto';
import { Product } from './interfaces/product.interface';
import { GeminiService } from '../gemini/gemini.service';

@Injectable()
export class ProductsService {
  private readonly logger = new Logger(ProductsService.name);

  constructor(private readonly geminiService: GeminiService) {}

  async create(createProductDto: CreateProductDto): Promise<Product> {
    try {
      this.logger.log(`Criando produto: ${createProductDto.name}`);

      const enhancedDescription =
        await this.geminiService.enhanceProductDescription(
          createProductDto.name,
          createProductDto.description,
          createProductDto.price,
        );

      const product: Product = {
        ...createProductDto,
        enhancedDescription,
      };

      this.logger.log(`Produto criado com sucesso: ${createProductDto.name}`);
      return product;
    } catch (error) {
      this.logger.error(
        `Falha ao criar produto: ${createProductDto.name}`,
        error instanceof Error ? error.stack : String(error),
      );
      throw error;
    }
  }
}

4. Implementando o Controlador da API REST

Agora, vamos criar o controlador que exporá nosso endpoint de criação de produtos:

Controlador de Produtos (src/products/products.controller.ts)

import {
  Controller,
  Post,
  Body,
  ValidationPipe,
  HttpException,
  HttpStatus,
  Logger,
} from '@nestjs/common';
import { ProductsService } from './products.service';
import { CreateProductDto } from './dto/create-product.dto';
import { Product } from './interfaces/product.interface';

@Controller('api/products')
export class ProductsController {
  private readonly logger = new Logger(ProductsController.name);

  constructor(private readonly productsService: ProductsService) {}

  @Post()
  async create(
    @Body(new ValidationPipe({ transform: true }))
    createProductDto: CreateProductDto,
  ): Promise<Product> {
    try {
      this.logger.log(
        `Recebida solicitação para criar produto: ${createProductDto.name}`,
      );
      return await this.productsService.create(createProductDto);
    } catch (error) {
      this.logger.error(
        'Falha ao criar produto',
        error instanceof Error ? error.stack : String(error),
      );

      if (
        error instanceof Error &&
        error.message === 'Falha ao gerar descrição aprimorada'
      ) {
        throw new HttpException(
          'Falha ao aprimorar descrição do produto. Por favor, tente novamente.',
          HttpStatus.SERVICE_UNAVAILABLE,
        );
      }

      throw new HttpException(
        'Erro interno do servidor',
        HttpStatus.INTERNAL_SERVER_ERROR,
      );
    }
  }
}

5. Configurando os Módulos

Finalmente, vamos configurar os módulos da nossa aplicação:

Módulo de Produtos (src/products/products.module.ts)

import { Module } from '@nestjs/common';
import { ProductsController } from './products.controller';
import { ProductsService } from './products.service';
import { GeminiService } from '../gemini/gemini.service';

@Module({
  controllers: [ProductsController],
  providers: [ProductsService, GeminiService],
})
export class ProductsModule {}

Módulo Principal (src/app.module.ts)

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { ProductsModule } from './products/products.module';

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
    }),
    ProductsModule,
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

---

Testando a API

Depois de implementar todos os componentes, você pode testar a API usando ferramentas como Postman, cURL ou Insomnia:

Exemplo de Requisição

POST http://localhost:3000/api/products
Content-Type: application/json

{
  "name": "Fones de Ouvido Bluetooth Sem Fio",
  "description": "Fones de ouvido sem fio com cancelamento de ruído",
  "price": 299.99
}

Exemplo de Resposta

{
  "name": "Fones de Ouvido Bluetooth Sem Fio",
  "description": "Fones de ouvido sem fio com cancelamento de ruído",
  "price": 299.99,
  "enhancedDescription": "Experimente liberdade sonora absoluta com nossos Fones de Ouvido Bluetooth Sem Fio, equipados com tecnologia avançada de cancelamento de ruído que transporta você para um mundo de áudio imersivo. Desfrute de músicas, podcasts e chamadas com qualidade cristalina, sem as distrações do ambiente externo, tudo isso por apenas R$299,99 – um investimento incrível para sua experiência auditiva premium."
}

---

Considerações de Segurança

Ao trabalhar com APIs de IA, lembre-se de:

1. Nunca expor sua chave de API no cliente ou no código-fonte público
2. Validar todas as entradas para prevenir injeção de prompt
3. Implementar rate limiting para evitar custos inesperados
4. Monitorar o uso da API para otimizar gastos

Considerações de Desempenho

Para garantir que sua aplicação funcione de forma eficiente mesmo sob carga:

1. Implemente timeouts para chamadas à API do Gemini
2. Configure retry logic para lidar com falhas temporárias
3. Considere um sistema de filas para solicitações assíncronas
4. Monitore a latência para identificar gargalos de desempenho

Conclusão

A combinação de NestJS e Google Gemini AI oferece uma solução poderosa e escalável para transformar descrições básicas de produtos em conteúdo de marketing persuasivo. Com apenas 10 minutos de configuração, você pode implementar uma API robusta que:

• Automatiza a criação de conteúdo de alta qualidade
• Economiza horas de trabalho manual de redação
• Mantém consistência na comunicação da sua marca
• Escala facilmente para milhares de produtos

Esta abordagem não apenas melhora a eficiência operacional, mas também pode aumentar significativamente suas taxas de conversão ao apresentar produtos de forma mais atraente e persuasiva para seus clientes.