Nest.js + IA Gemini: Transforme Descrições Simples em Conteúdo Profissional em 10 minutos
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: 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á: Configurando o Acesso à API do Google Gemini 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) Detalhamento das Dependências Arquitetura do Projeto Para manter nosso código organizado e escalável, seguiremos a estrutura de pastas recomendada pelo NestJS: 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: 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) DTO de Criação de Produto (src/products/dto/create-product.dto.ts) 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) 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) 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) 5. Configurando os Módulos Finalmente, vamos configurar os módulos da nossa aplicação: Módulo de Produtos (src/products/products.module.ts) Módulo Principal (src/app.module.ts) 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 Exemplo de Resposta Considerações de Segurança Ao trabalhar com APIs de IA, lembre-se de: Considerações de Desempenho Para garantir que sua aplicação funcione de forma eficiente mesmo sob carga: 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: 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.
Analisando PDFs com a OpenAI
A API da OpenAI possui recursos de visão que permitem que você envie arquivos, como PDFs, para processamento. Com modelos de IA, você pode extrair informações de documentos complexos, como resumos, respostas a perguntas específicas ou até mesmo análise de conteúdo. Neste artigo, vamos explorar como integrar arquivos PDF com a API da OpenAI de forma prática, utilizando C#. Capacidade de visão dos modelos A OpenAI oferece modelos que suportam a entrada de arquivos, como imagens e PDFs. Esses modelos aproveitam a tecnologia de visão computacional para processar e analisar documentos e imagens de maneira inteligente. Quando você fornece um PDF como entrada, o modelo pode realizar várias tarefas, como: Extração de conteúdo: o modelo pode ler e entender o texto do PDF, identificando parágrafos, seções e outros elementos. Resumos: o modelo pode resumir o conteúdo do documento, oferecendo uma visão geral ou uma versão condensada. Resposta a perguntas: após analisar o documento, o modelo pode responder a perguntas com base no conteúdo fornecido. Análise de estrutura: em documentos mais complexos, o modelo pode identificar a estrutura e organizar as informações de maneira eficiente. Essas funcionalidades são ideais para trabalhar com documentos como contratos, relatórios financeiros, apostilas e muito mais. Implementação O primeiro passo é configurar as variáveis que serão usadas ao longo do código. Vamos criar as variáveis para o caminho do arquivo, a chave da API da OpenAI e as URLs para fazer as requisições. Também vamos criar uma instância do HttpClient para as requisições. using System.Text; using System.Text.Json; using System.Net.Http.Headers; namespace ChatGPTConsoleApp { public class Program { private static readonly HttpClient client = new HttpClient(); private static string filePath = @”D:Arquivo_Analise.pdf”; private static string apiKey = “SUA_CHAVE_API”; private static string urlFiles = “https://api.openai.com/v1/files”; private static string urlBase = “https://api.openai.com/v1/responses”; Agora, dentro do método “Main”, vamos implementar os métodos responsáveis por fazer o upload do arquivo PDF para a OpenAI e enviar uma pergunta ao modelo do GPT sobre o conteúdo do arquivo que foi carregado, utilizando o “idArquivo” retornado na primeira etapa. public static async Task Main(string[] args) { string idArquivo = await UploadPdf(); string resposta = await PerguntarSobreOArquivo(“Escreva um resumo do arquivo”, idArquivo); Console.WriteLine(resposta); } O fluxo do código será o seguinte: primeiro, o método “UploadPdf” envia o arquivo PDF, que está localizado no caminho armazenado na variável “filePath”, e retorna o “idArquivo”. Em seguida, o método “PerguntarSobreOArquivo” utiliza esse “idArquivo” para enviar uma pergunta ao modelo sobre o conteúdo do arquivo. Após receber a resposta do modelo, ela será exibida na tela para o usuário. Agora vamos implementar o primeiro método, “UploadPdf”: public static async Task UploadPdf() { var fileContent = new ByteArrayContent(File.ReadAllBytes(filePath)); fileContent.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue(“application/pdf”); O método “File.ReadAllBytes(filePath)” lê o arquivo PDF no caminho especificado e o armazena como um array de bytes. Isso é necessário para enviar o conteúdo binário do arquivo em uma requisição HTTP. A classe “ByteArrayContent” permite que você envie dados binários (como o conteúdo de um arquivo) através de uma requisição HTTP. O cabeçalho “Content-Type” é configurado para “application/pdf”, que indica que o conteúdo sendo enviado é um arquivo PDF. using (var formData = new MultipartFormDataContent()) { formData.Add(fileContent, “file”, Path.GetFileName(filePath)); formData.Add(new StringContent(“user_data”), “purpose”); A classe “MultipartFormDataContent” é usada para enviar arquivos e dados em um formato multipart (como o tipo de conteúdo “multipart/form-data”), que é o padrão para uploads de arquivos na web. Após isso, o “formData.Add(fileContent, “file”, Path.GetFileName(filePath))” está adicionando o arquivo à requisição. O nome do campo será “file”, e o nome do arquivo será extraído usando “Path.GetFileName(filePath)”, que retorna apenas o nome do arquivo (sem o caminho). Em seguida o “formData.Add(new StringContent(“user_data”), “purpose”)” adiciona um campo de texto chamado “purpose” com o valor “user_data”, informando à OpenAI que o arquivo está sendo enviado com a finalidade de ser utilizado como dados do usuário. Agora que o arquivo foi configurado, vamos montar o cabeçalho e realizar o envio: client.DefaultRequestHeaders.Add(“Authorization”, $”Bearer {apiKey}”); var response = await client.PostAsync(urlFiles, formData); O cabeçalho de autorização é configurado com o tipo “Bearer”, que é usado para autenticação em APIs. O valor do token “({apiKey})” será substituído pela chave da API que você tem para autenticação na OpenAI. Após isso, enviamos um POST para o endpoint da API da OpenAI. Após processar, receberemos uma resposta: if (response.IsSuccessStatusCode) { var responseContent = await response.Content.ReadAsStringAsync(); using (JsonDocument doc = JsonDocument.Parse(responseContent)) { var fileId = doc.RootElement .GetProperty(“id”) .GetString(); return fileId; } } Vamos validar se o status da requisição foi de sucesso. Depois, lê o conteúdo da resposta da API como uma string. O conteúdo é esperado como um JSON. Com isso, é possível recuperar o campo “id” do json que é o que vamos usar para realizar as perguntas. else { Console.WriteLine(“Erro ao carregar o arquivo: ” + response.ReasonPhrase); return null; } } Se a resposta não for bem-sucedida, a propriedade “ReasonPhrase” contém uma descrição do erro, que é exibida no console. Agora vamos implementar o método “PerguntarSobreOArquivo”. Esse método recebe dois parâmetros, o “prompt” que contém a nossa pergunta e o “fileId” que contém o id do documento que enviamos: public static async Task PerguntarSobreOArquivo(string prompt, string fileId) { var json = JsonSerializer.Serialize(new { model = “gpt-4.1”, input = new[] { new { role = “user”, content = new List { new { type = “input_file”, file_id = fileId }, new { type = “input_text”, text = prompt } } } } }); Primeiro, criamos uma variável “json” que irá armazenar o conteúdo da nossa requisição em formato JSON. Utilizamos o “JsonSerializer” para serializar um objeto anônimo que contém todas as informações necessárias. Esse método inicia informando qual o modelo que será utilizado para a consulta. No caso, estamos usando o modelo “gpt-4.1”. Em seguida, repassamos no “content” um array que contém dois objetos, um “input_file” que recebe o id do arquivo e o “input_text” que recebe a nossa pergunta. Agora vamos criar o corpo da nossa requisição: var requestBody = new StringContent(json, Encoding.UTF8, “application/json”); O JSON gerado na etapa anterior é convertido em uma string e empacotado em um objeto “StringContent”.
Integre suas aplicações .NET com o DeepSeek
Recentemente, a start-up chinesa DeepSeek tem ganhado destaque no campo da inteligência artificial com seu revolucionário chatbot de IA generativa. O modelo da DeepSeek alcançou um nível de desempenho comparável aos de gigantes como OpenAI e Anthropic, mas com um custo significativamente mais baixo. Neste artigo, iremos explorar como integrar a API DeepSeek em uma aplicação .NET, mostrando passo a passo como configurar, enviar e processar mensagens para criar uma experiência de bate-papo inteligente e fluída. Se você deseja adicionar funcionalidades de conversação inteligente ao seu projeto, este guia prático é o ponto de partida perfeito. Criando uma conta no DeepSeek Acesse o site oficial do DeepSeek. Preencha o formulário com seu e-mail e senha. Após criar sua conta, faça login e vá até a seção API Keys no painel de controle e clique em “Create new API Key”, copie e guarde a chave gerada. Configurando a API Key Agora, no código que vamos escrever, você deve inserir sua chave de API gerada no DeepSeek. No exemplo abaixo, a chave de API é armazenada diretamente na variável apiKey. Em aplicações reais, evite armazenar a chave diretamente no código fonte. Em vez disso, você pode armazená-la em uma variável de ambiente ou em um arquivo de configuração. public class Program { private static readonly string apiKey = “Sua-chave”; private static readonly string baseUrl = “https://api.deepseek.com/chat/completions”; public static async Task Main(string[] args) { //nosso código } } Função principal para envio de mensagens Na “Main”, começamos inicializando a lista de mensagens e configuramos o sistema para enviar as mensagens ao modelo de chat da API DeepSeek. A API requer um formato específico de dados para a comunicação. Aqui, o código define um ponto de entrada para a conversa, onde o sistema envia uma mensagem de saudação inicial ao DeepSeek: Console.WriteLine(“Iniciando conversa com o DeepSeek…”); var messages = new List(); messages.Add(new { role = “system”, content = “Você é um assistente inteligente e amigável.” } Esse código simula uma conversa onde o “role” define quem está enviando a mensagem. Já o “content” armazena qual o comportamento do assistente. Leitura da entrada do usuário e envio de solicitações Agora vamos criar um “while” que vai continuar pedindo mensagens ao usuário e as envia para o DeepSeek. Caso o usuário queira parar o “while” ele teve enviar uma mensagem vazia: while (true) { //…código do processamento aqui } Os próximos blocos de código devem ser inseridos dentro do while(true). Console.Write(“Você: “); string userMessage = Console.ReadLine(); if (string.IsNullOrEmpty(userMessage)) break; Após escrever a mensagem, nós vamos adicionar ela na lista de mensagens: messages.Add(new { role = “user”, content = userMessage }); Em seguida, vamos montar o corpo da nossa requisição para enviar a solicitação ao DeepSeek. Essa requisição vai conter todas as mensagens trocadas até aquele momento (usuário e assistente): var requestData = new { model = “deepseek-chat”, messages = messages.ToArray(), stream = false }; Enviando a solicitação HTTP para a API Agora vamos usar a classe “HttpClient” para enviar uma requisição POST: using var httpClient = new HttpClient(); string jsonRequest = JsonSerializer.Serialize(requestData); var content = new StringContent(jsonRequest, Encoding.UTF8, “application/json”); httpClient.DefaultRequestHeaders.Add(“Authorization”, $”Bearer {apiKey}”); var response = await httpClient.PostAsync(baseUrl, content); Aqui, a chave de API é passada no cabeçalho da requisição através do cabeçalho “Authorization”. Tratando a resposta da API Após isso, é necessário analisar a resposta da API e extrair a resposta do modelo. A API DeepSeek retorna a resposta em um formato JSON, e usamos “JsonDocument” para processá-la: var responseBody = await response.Content.ReadAsStringAsync(); using JsonDocument jsonDoc = JsonDocument.Parse(responseBody); string contentText = jsonDoc .RootElement .GetProperty(“choices”)[0] .GetProperty(“message”) .GetProperty(“content”) .GetString() O resultado será apenas a resposta do modelo sem os demais dados. Apresentando as informações e armazenando a nova mensagem Por fim, podemos apresentar a resposta do modelo na tela e adicionar a mensagem recebida na lista de mensagens e continuando no ‘while’: Console.WriteLine($”DeepSeek: {contentText }”); messages.Add(new { role = “assistant”, content = contentText }); Na imagem abaixo podemos ver uma demonstração da aplicação em funcionamento: Acelere a sua carreira conosco! Se você é Desenvolvedor .NET Júnior e quer acelerar sua carreira até nível Pleno com salário de R$7k+, ou mesmo busca a primeira vaga, conheça a Mentoria .NET Start: Clique aqui Se é Desenvolvedor .NET Pleno ou Sênior e quer virar referência técnica em sua equipe e mercado, com salário de R$10k+, conheça a Mentoria .NET Expert: Clique aqui Conclusão Neste artigo, nós vimos como integrar com a API DeepSeek em um aplicativo .NET para criar uma aplicação de bate-papo simples. Com base nesse código, você pode expandir a funcionalidade para criar interfaces gráficas, armazenar o histórico de mensagens em um banco de dados, ou até mesmo integrar com outras APIs ou sistemas.
Crie um assistente virtual em .NET com a API da OpenAI
Com a crescente demanda por soluções inteligentes, integrar assistentes de IA em aplicações tornou-se uma oportunidade valiosa para desenvolvedores. Para isso, a OpenAI ampliou suas capacidades com a API Assistants, permitindo a criação de assistentes personalizados com funcionalidades avançadas. Neste artigo, exploraremos como utilizar essa API, desde a configuração inicial até exemplos práticos. Quais as diferenças entre a API do ChatGPT e a API Assistants? A API Assistants e a API tradicional do ChatGPT compartilham a base tecnológica dos modelos avançados da OpenAI, mas possuem abordagens distintas quanto à funcionalidade e ao uso: Personalização e instruções específicas: ChatGPT: possui um foco mais direto em responder perguntas e participar de conversas com base nas mensagens enviadas. Assistants: permite configurar assistentes com instruções específicas para definir a personalidade e os limites do assistente, ajustando-o para diferentes casos de uso. Threads persistentes: ChatGPT: não armazena o histórico de conversas diretamente. Assistants: trabalha com Threads que armazenam o histórico de mensagens, possibilitando a continuidade das interações mesmo após múltiplas consultas. Manipulação de arquivos: ChatGPT: não interage diretamente com arquivos. Assistants: suporta o acesso e manipulação de arquivos em diversos formatos, além de citar arquivos e criar novos durante a execução de tarefas. Configuração inicial Para fins didáticos, utilizaremos aqui uma aplicação do tipo Console. Então, para começar, vamos organizar a estrutura básica da nossa aplicação de forma clara: public class Program { private static readonly string apiKey = “”; // Substitua com sua chave de API private static readonly string apiUrl = “https://api.openai.com/v1″; private static string assistantId; private static string threadId; public static async Task Main(string[] args) { try { //Implementação do nosso código. } catch (Exception ex) { Console.WriteLine($”Erro geral: {ex.Message}”); } } private static async Task CriarAssistente() { } private static async Task CriarThread() { } private static async Task EnviarMensagem(string assistantId, string threadId, string Mensagem) { } private static async Task BuscarMensagens(string threadId) { } } Dentro da classe “Program” nós criamos quatro variáveis. Na variável “apiKey” deve ser armazenada a chave de API da OpenAI. Caso tenha dúvidas de como conseguir essa chave, você pode ver o passo a passo neste tutorial. A URL base (apiUrl) é fixa e aponta para o endpoint de interações com assistentes. A variável “assistantId” vai armazenar o id da nossa assistente e a “threadId” vai armazenar o id da thead que vamos criar. O método principal será a “Main”, responsável por iniciar a execução do sistema e controlar o fluxo principal da interação com a API da OpenAI. Além dela, contaremos com quatro métodos que desempenham funções específicas: CriarAssistente: Este método será responsável por enviar uma requisição para a criação de um assistente virtual. Ele configurará parâmetros como instruções iniciais e o modelo que será utilizado. CriarThread: Após a criação do assistente, será necessário criar uma thread associada a ele, onde as mensagens e respostas serão organizadas. Este método realiza essa tarefa. EnviarMensagem: Uma vez que a thread estiver configurada, este método permitirá enviar mensagens para o assistente virtual, incluindo instruções e dados adicionais conforme necessário. BuscarMensagens: Este método será responsável por recuperar as mensagens da thread, exibindo as respostas geradas pelo assistente. Criando o assistente virtual A primeira etapa para interagir com a API do OpenAI é criar um assistente. Vamos definir algumas configurações iniciais no método “CriarAssistente”: private static async Task CriarAssistente() { using var client = new HttpClient(); var data = new { instructions = “Você é um professor de matemática que auxilia seus alunos.”, name = “Professor”, tools = new List { new { type = “file_search” }, new { type = “code_interpreter” } }, model = “gpt-4-turbo” }; //…continua } Aqui nós criamos uma instância de “HttpClient” para realizarmos as requisições. Após isso, montamos o objeto da nossa requisição que vai conter a instrução do que nossa assistente deve fazer, o seu nome, uma lista de ferramentas que o assistente pode usar como pesquisa de arquivos e interpretação de código. E por fim, o modelo que usaremos. Ainda dentro do método “CriarAssistente”, vamos montar a nossa requisição e envia-la: var request = new HttpRequestMessage(HttpMethod.Post, $”{apiUrl}/assistants”) { Content = new StringContent(JsonSerializer.Serialize(data), Encoding.UTF8, “application/json”) }; request.Headers.Add(“Authorization”, $”Bearer {apiKey}”); request.Headers.Add(“OpenAI-Beta”, “assistants=v2”); var response = await client.SendAsync(request); Após realizar o envio da requisição, vamos ler a informação que foi retornada: var result = await response.Content.ReadAsStringAsync(); using var doc = JsonDocument.Parse(result); return doc.RootElement.GetProperty(“id”).GetString(); No código acima, após realizarmos a leitura da nossa resposta, vamos armazená-la em “result”. Após isso, vamos transformar o valor recebido em um JSON para permitir o acesso estruturado aos seus dados. O código então vai navegar até a raiz do documento (RootElement) e extrair o valor associado à propriedade “id”, convertendo-o em uma string com “GetString()”. Com isso, conseguimos capturar o id da nossa assistente. Criando a thread de conversa Após criar o assistente, precisamos de uma “thread” (ou conversa) onde as interações acontecerão. private static async Task CriarThread() { using var client = new HttpClient(); var data = new { metadata = new { project = “AulasMatematica” } }; //Aqui o objeto “data” vai conter as informações do projeto que você está criando. var request = new HttpRequestMessage(HttpMethod.Post, $”{apiUrl}/threads”) { Content = new StringContent(JsonSerializer.Serialize(data), Encoding.UTF8, “application/json”) }; request.Headers.Add(“Authorization”, $”Bearer {apiKey}”); request.Headers.Add(“OpenAI-Beta”, “assistants=v2”); var response = await client.SendAsync(request); var result = await response.Content.ReadAsStringAsync(); using var doc = JsonDocument.Parse(result); return doc.RootElement.GetProperty(“id”).GetString(); } O código acima vai seguir o mesmo fluxo da criação da assistente, retornando o id da thread que foi criada. Enviando mensagens para o assistente Agora que temos o assistente e a thread criados, podemos enviar mensagens para o assistente da seguinte forma: private static async Task SendMessageAsync(string assistantId, string threadId, string mensagem) { using var client = new HttpClient(); var data = new { assistant_id = assistantId, instructions = “Responda apenas às perguntas referentes a matemática. Caso seja falado sobre outros assuntos, responda educadamente para voltar para assuntos relacionados a matemática.”, additional_messages = new[] { new { role = “user”, content = mensagem} } }; //…continua } Aqui, a variável “data” guarda o “assistantId” do assistente que
Integrando o Google Gemini em aplicações .NET
A API do Google Gemini permite criar conteúdo de forma automatizada, utilizando a inteligência artificial para gerar texto baseado em modelos avançados. Neste artigo vamos aprender a integrar API Gemini em um projeto .NET usando uma aplicação de console, incluindo desde a configuração inicial até um exemplo prático de requisição. Criando a chave de API no Google AI Studio Acesse o Google AI Studio e faça login na sua conta. Após o login, clique em “Get API Key” e, em seguida, em “Criar chave de API”. Se você ainda não tiver criado uma chave de API, ela será gerada automaticamente. Caso contrário, será necessário escolher o projeto desejado e criar uma nova chave. Após a criação da chave, copie o valor gerado e armazene-o em um local seguro, pois usaremos essa chave para realizar as requisições à API. Configurando o projeto Agora, vamos criar um projeto de console para implementar o nosso exemplo. Para isso, execute os comandos abaixo para iniciar um novo projeto usando a .NET CLI: dotnet new console -n GoogleGeminiExemplo cd GoogleGeminiExemplo Implementação O primeiro passo será criar duas constantes para armazenar a chave da API e a URL base para a requisição à API do Google Gemini. Substitua “COLOQUE_AQUI_SUA_KEY” pela sua chave de API que criamos anteriormente. public static class Program { private const string ApiKey = “COLOQUE_AQUI_SUA_KEY”; private const string BaseUrl = “https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash-latest:generateContent?key=”; } Essas variáveis são necessárias para configurar a requisição e permitir a comunicação com a API. Agora, vamos configurar o ponto de entrada da aplicação. No método “Main”, criaremos o conteúdo de texto (prompt) que será enviado para a API e chamaremos o método para fazer a requisição. public static async Task Main(string[] args) { var prompt = “Quais as vantagens de estudar programação?”; using var client = new HttpClient(); var requestBody = new { contents = new[] { new { parts = new[] { new { text = prompt } } } } }; // Processo de requisição continua aqui… } No código acima, nós criamos uma variável chamada “prompt” para poder armazenar a pergunta que será enviada. Também vamos criar uma nova instância do “HttpClient” para podermos enviar a nossa requisição e criar uma variável “requestBody” que vai conter o corpo da nossa requisição. Segundo a documentação da API, a requisição deve seguir o formato abaixo: Para representar esse formato em C#, podemos utilizar um tipo anônimo que terá a estrutura igual a variável “requestBody”. Esse tipo anônimo possui a mesma estrutura, com uma chave “contents”, que é um array contendo objetos com a chave “parts”, que por sua vez contém um array de objetos com a chave “text”. O valor de “text” será o prompt que passamos como argumento para o método. Em seguida, enviamos a requisição usando o método “PostAsJsonAsync”, que serializa automaticamente o “requestBody” em JSON e define o “Content-Type” corretamente. var response = await client.PostAsJsonAsync($”{BaseUrl}{ApiKey}”, requestBody); Após a requisição ser enviada, vamos verificar se a resposta foi bem-sucedida. Caso positivo, a resposta será desserializada diretamente para um objeto do tipo “RespostaGemini”. Caso contrário, apresentamos o erro na tela do console. if (response.IsSuccessStatusCode) { var resultado = await response.Content.ReadFromJsonAsync(); Console.WriteLine(“Response from API:”); if (resultado?.Candidates != null && resultado.Candidates.Count > 0) { Console.WriteLine(resultado.Candidates[0].Content.Parts[0].Text); } } else { var errorResponse = await response.Content.ReadAsStringAsync(); Console.WriteLine($”Error: {errorResponse}”); } No código acima, verificamos se a propriedade “Candidates” não é nula e se contém pelo menos um item. Se ambas as condições forem satisfeitas, exibimos o texto que contém a resposta para a pergunta enviada na requisição. Para desserializar a resposta da API de maneira adequada, precisamos criar classes que representam a estrutura do JSON retornado. O exemplo a seguir mostra como isso pode ser feito: public class RespostaGemini { public List Candidates { get; set; } } public class Candidate { public Content Content { get; set; } } public class Content { public List Parts { get; set; } } public class Part { public string Text { get; set; } } Essas classes correspondem à estrutura do JSON retornado pela API, permitindo que possamos acessar o conteúdo gerado de forma simples. Agora, se colocarmos a nossa aplicação para ser executada, vamos receber uma resposta semelhante a esta: Acelere a sua carreira conosco! Se você é Desenvolvedor .NET Júnior e quer acelerar sua carreira até nível Pleno com salário de R$7k+, ou mesmo busca a primeira vaga, conheça a Mentoria .NET Start: Clique aqui Se é Desenvolvedor .NET Pleno ou Sênior e quer virar referência técnica em sua equipe e mercado, com salário de R$10k+, conheça a Mentoria .NET Expert: Clique aqui Conclusão Integrar a API do Google Gemini em um projeto .NET é um processo que oferece uma forte capacidade de geração de conteúdo utilizando a inteligência artificial de forma simples e eficaz. Certifique-se de sempre monitorar suas requisições, implementar boas práticas de segurança e otimização e estar atento às atualizações das APIs para garantir que suas soluções estejam alinhadas com o melhor que a tecnologia pode oferecer. Assim, você estará preparado para impulsionar suas aplicações ao próximo nível com o poder da inteligência artificial.
Reconhecimento facial em .NET com Kairos
A validação biométrica está se tornando uma ferramenta indispensável em um mundo cada vez mais digital, desempenhando um papel crucial em áreas como segurança e autenticação de usuários. Com o crescimento das preocupações relacionadas à segurança e à privacidade, soluções que utilizam características únicas do ser humano, como impressões digitais, reconhecimento facial e íris, têm se destacado pela eficácia e precisão. O que é a API Kairos? A Kairos é uma API de reconhecimento facial que utiliza inteligência artificial para identificar e verificar pessoas com base em características faciais. A API oferece a funcionalidade de verificação biométrica, que compara duas imagens para confirmar a identidade do usuário. Implementação da validação biométrica Para ilustrar o nosso exemplo, vamos considerar um cenário em que queremos validar a identidade de um funcionário usando uma selfie e uma imagem que foi armazenada no momento do seu cadastro. O primeiro passo que devemos tomar é definir as variáveis que serão utilizadas ao longo do código: string apiUrl = “https://idv-eu.kairos.com/v0.1/biometric-verification”; string appId = “IdentificadorAPP”; string appKey = “ChaveDaSuaAPI”; string selfieFilePath = @”C:CaminhodaImagemSelfie.jpg”; string imageFilePath = @”C:CaminhodaImagemArmazenada.png”; A variável “apiUrl” contém a URL da API Kairos para verificação biométrica. As variáveis “appId” e “appKey” são as credenciais necessárias para autenticar a requisição na API, e é importante que sejam substituídas pelos valores correspondentes de sua conta na Kairos. “selfieFilePath” e “imageFilePath” armazenam os caminhos para os arquivos de imagem que serão utilizados no processo de validação. É crucial garantir que esses caminhos estejam corretos e que as imagens existam para evitar erros durante a execução. if (!File.Exists(selfieFilePath) || !File.Exists(imageFilePath)) { Console.WriteLine(“Erro: Um ou mais arquivos de imagem não foram encontrados.”); return; } Aqui, realizamos uma verificação para garantir que os arquivos de imagem especificados existam. Se qualquer um dos arquivos não for encontrado, vamos exibir uma mensagem de erro, e o programa será encerrado. Essa etapa é importante para evitar que a aplicação falhe mais adiante ao tentar acessar arquivos inexistentes. using (var client = new HttpClient()) { var request = new HttpRequestMessage { Method = HttpMethod.Post, RequestUri = new Uri(apiUrl), Headers = { { “app_id”, appId }, { “app_key”, appKey }, }, Content = new MultipartFormDataContent { // Adiciona a selfie do usuário new StreamContent(File.OpenRead(selfieFilePath)) { Headers = { ContentDisposition = new ContentDispositionHeaderValue(“form-data”) { Name = “selfie”, FileName = Path.GetFileName(selfieFilePath), } } }, // Adiciona a imagem armazenada new StreamContent(File.OpenRead(imageFilePath)) { Headers = { ContentDisposition = new ContentDispositionHeaderValue(“form-data”) { Name = “image”, FileName = Path.GetFileName(imageFilePath), } } }, }, }; Neste bloco criamos uma instância do “HttpClient”, que será utilizada para enviar a requisição. Em seguida, configuramos um “HttpRequestMessage”, definindo o método HTTP como POST e especificando a URL da API. Os cabeçalhos de autenticação são adicionados utilizando “app_id” e “app_key”. O conteúdo da requisição é um “MultipartFormDataContent”, que permite enviar múltiplos arquivos como parte da requisição. Aqui, utilizamos “StreamContent” para ler os arquivos de imagem diretamente do sistema de arquivos. Os cabeçalhos “ContentDisposition” são configurados para cada arquivo, especificando o nome do campo e o nome do arquivo, o que é necessário para a API entender quais dados estão sendo enviados. using (var response = await client.SendAsync(request)) { response.EnsureSuccessStatusCode(); var body = await response.Content.ReadAsStringAsync(); Console.WriteLine(body); } Por fim, vamos enviar a requisição utilizando o método “SendAsync” do “HttpClient”. Após enviar a requisição, usamos “EnsureSuccessStatusCode” para garantir que a resposta da API foi bem-sucedida. Caso contrário, uma exceção será lançada. Em seguida, lemos o corpo da resposta e o exibimos no console. A resposta da API será algo semelhante a isso. Vamos entender os principais campos deste json: { “api_req_uid”: “2f960394-96c9-4403-b34d-92b1e33f7b7c”, “processed_at”: “2024-10-02 02:50:30”, “requested_at”: “2024-10-02 02:50:30”, “response_code”: 0, “response_data”: { “biometric”: { “image”: { “faces_match_confidences”: [ 1.0 ], “faces_predicted”: [ { “confidence”: 0.9357, “delta”: { “x”: 199.7969, “y”: 233.3345 }, “top_left”: { “x”: 233.5239, “y”: 162.5957 } } ], “img”: { “height”: 480, “width”: 640 } }, “max_facematch_confidence”: 1.0, “selfie”: { “faces_liveness”: 1.0, “faces_predicted”: [ { “confidence”: 1.0, “delta”: { “x”: 161.1886, “y”: 219.9249 }, “top_left”: { “x”: 297.8376, “y”: 196.7119 } } ], “img”: { “height”: 799, “width”: 735 } } }, “decision”: { “details”: [], “reject_score”: 0.0, “review_score”: 0.0, “warning_score”: 0.0 } } } response_code: Indica o status da resposta. Um código 0 geralmente significa que a solicitação foi processada com sucesso, sem erros. faces_match_confidences: Um array que armazena as pontuações de confiança da correspondência entre os rostos detectados na imagem submetida e na selfie. Neste exemplo, a confiança máxima foi de 1.0, indicando uma correspondência precisa. faces_liveness: Indica a verificação de vivacidade da selfie, ou seja, se a imagem foi tirada de uma pessoa viva. Um valor de 1.0 significa que a vivacidade foi confirmada com sucesso. reject_score: Indica a pontuação de rejeição da verificação. Um valor 0.0 significa que a verificação foi bem-sucedida. review_score e warning_score: Pontuações que indicam se há necessidade de revisão manual ou algum aviso relacionado ao processo de verificação. No exemplo, ambas estão em 0.0, sugerindo que não há problemas ou necessidade de revisão. Em casos onde a verificação não é bem-sucedida, o sistema pode gerar uma decisão negativa, como no exemplo a seguir: “decision”:{ “details”:[ { “code”:”FAILED_FACE_MATCH”, “confidence”:1.0, “decision”:”reject”, “description”:”Faces do not match; threshold failed: 0.2285; x < 0.4" } ], "reject_score":1.0, "review_score":0.0, "warning_score":0.0 } Neste exemplo, o sistema retorna um “reject_score” de 1.0, indicando que a verificação foi rejeitada. A descrição informa que “Os rostos não correspondem; limite falhou: 0.2285; x < 0.4”, o que significa que a pontuação de semelhança foi inferior ao limite necessário (0.4). Isso resultou em uma decisão negativa, pois semelhanças abaixo de 0.4 são consideradas insuficientes para validar a correspondência entre os rostos. Acelere a sua carreira conosco! Se você é Desenvolvedor .NET Júnior e quer acelerar sua carreira até nível Pleno com salário de R$7k+, ou mesmo busca a primeira vaga, conheça a Mentoria .NET Start: Clique aqui Se é Desenvolvedor .NET Pleno ou Sênior e quer virar referência técnica em sua equipe e mercado, com salário de R$10k+, conheça a Mentoria .NET Expert: Clique aqui Conclusão A validação biométrica está se
OpenAI Vision: Descrevendo imagens em C#
Neste artigo exploraremos como utilizar o serviço de Visão da OpenAI para entender e analisar imagens.
Moderação de conteúdo com a OpenAI em .NET
A moderação de conteúdo é uma parte crucial na gestão de plataformas online, garantindo que o conteúdo publicado esteja de acordo com as diretrizes da comunidade e evitando a disseminação de informações prejudiciais. A OpenAI oferece uma API de moderação que pode ser integrada em projetos .NET para analisar e moderar automaticamente o conteúdo. Modelo de moderação utilizado A API de moderação da OpenAI utiliza o modelo “text-moderation-007”, projetado para analisar textos e identificar categorias de conteúdo inadequado, como violência, assédio, discurso de ódio, entre outros. Este modelo funciona avaliando o conteúdo de entrada e retornando um conjunto de categorias com pontuações que indicam a probabilidade de cada categoria estar presente no texto. Aplicação em projetos reais A moderação automática de conteúdo pode ser aplicada em diversas áreas, como: Redes sociais: filtragem de postagens, comentários e mensagens privadas. Plataformas de e-commerce: moderação de avaliações e comentários de produtos. Fóruns e comunidades online: monitoramento de tópicos e respostas para garantir um ambiente saudável. Aplicativos de mensagens: prevenção de assédio e spam em conversas. Com isso, podemos perceber que a integração da API de moderação da OpenAI em um projeto .NET pode ajudar a manter a integridade e a segurança da plataforma, reduzindo a necessidade de intervenção manual. Implementação da API Indo para a nossa aplicação de exemplo, vamos utilizar um projeto de API construído em ASP.NET que será responsável por receber o conteúdo a ser moderado e fazer a integração com a API de moderação da OpenAI. Para nos comunicarmos com a API de moderação, precisaremos de uma chave de API. Caso você não tenha uma chave de API da OpenAI, você pode seguir nosso tutorial detalhado, que cobre desde a criação da conta na plataforma até a geração e configuração da chave de API necessária para utilizar os serviços de moderação. Após gerar o nosso projeto e criar a chave de API, devemos criar um controller chamado “ContentModerationController” e uma action do tipo POST chamada “ModerateContent”, recebendo um parâmetro do tipo string com o nome “content”, que será o texto que enviaremos para a API de moderação da OpenAI. Adicionamos também um bloco try-catch para lidar com eventuais erros que possam ocorrer durante o processo de moderação. using Microsoft.AspNetCore.Mvc; using System.Text.Json; using System.Text; using System.Net.Http; namespace ContentModerationApp.Controllers { [Route(“api/[controller]”)] [ApiController] public class ContentModerationController : ControllerBase { [HttpPost] public async Task ModerateContent(string content) { try { // Nosso código de interação para moderação de conteúdo. } catch (Exception ex) { return StatusCode(500, $”Erro ao moderar conteúdo: {ex.Message}”); } } } } Com a estrutura base do nosso projeto ASP.NET definida, o primeiro passo é armazenar a chave de API gerada no site da OpenAI em uma string dentro do bloco “try” para que possamos utilizá-la em nossas requisições. string openaiApiKey = “sua chave aqui”; Em seguida, vamos construir o corpo da requisição. Aqui, definimos a mensagem que desejamos moderar, que é passada através do parâmetro “content”. var requestBody = new { input = content }; Para enviar a requisição HTTP, precisamos serializar o objeto “requestBody” para o formato JSON. var requestBodyJson = JsonSerializer.Serialize(requestBody); Agora vamos criar um cliente HTTP utilizando “HttpClient” para enviar uma solicitação POST à API da OpenAI. using (var httpClient = new HttpClient()) { //Código da requisição. } Vamos também adicionar dentro do cliente HTTP a chave de autorização no cabeçalho da requisição para garantir que a solicitação seja autenticada corretamente. httpClient.DefaultRequestHeaders.Add(“Authorization”, $”Bearer {openaiApiKey}”); Depois de configurar o cliente HTTP com a chave de autorização, o próximo passo é enviar uma requisição POST para a API da OpenAI. O corpo da requisição contém os dados necessários para a moderação de conteúdo, que foram previamente serializados em JSON. var response = await httpClient.PostAsync(“https://api.openai.com/v1/moderations”, new StringContent(requestBodyJson, Encoding.UTF8, “application/json”)); Após enviar a requisição, precisamos processar a resposta recebida da API. O código a seguir verifica se a resposta foi bem-sucedida e lê o corpo da resposta como uma string. if (response.IsSuccessStatusCode) { string responseBody = await response.Content.ReadAsStringAsync(); return Ok(responseBody); } else { return BadRequest(response.StatusCode); } Analisando a resposta Ao executarmos nossa API e enviarmos uma requisição, receberemos uma resposta da API de moderação da OpenAI no formato JSON, contendo informações detalhadas sobre o conteúdo analisado. A seguir, apresentamos um exemplo de resposta juntamente com sua explicação. { “id”: “modr-9ijvCEVyMvw36jrtEhS0WlofXm9mt”, “model”: “text-moderation-007”, “results”: [ { “flagged”: false, “categories”: { “sexual”: false, “hate”: false, “harassment”: false, “self-harm”: false, “sexual/minors”: false, “hate/threatening”: false, “violence/graphic”: false, “self-harm/intent”: false, “self-harm/instructions”: false, “harassment/threatening”: false, “violence”: false }, “category_scores”: { “sexual”: 0.000013486678653862327, “hate”: 0.09813056141138077, “harassment”: 0.200340136885643, “self-harm”: 0.0008290316327475011, “sexual/minors”: 5.089680712444533e-7, “hate/threatening”: 0.044729895889759064, “violence/graphic”: 0.0017252579564228654, “self-harm/intent”: 0.000022909627659828402, “self-harm/instructions”: 0.000021325766283553094, “harassment/threatening”: 0.18670909106731415, “violence”: 0.000022909627659828402 } } ] } O campo “id” identifica exclusivamente a requisição de moderação de conteúdo dentro do sistema da OpenAI. Cada requisição feita à API recebe um ID único. O campo “model” indica o modelo utilizado para realizar a moderação de conteúdo. Neste caso, o modelo é o text-moderation-007, que citamos anteriormente. O campo “flagged” indica se o texto analisado foi marcado como problemático ou inapropriado pelo modelo. Neste exemplo, “flagged” está definido como false, indicando que o texto analisado não contém nenhum tipo de conteúdo que possa ser considerado inadequado. Este campo é especialmente útil em sistemas de moderação onde qualquer ocorrência de conteúdo inadequado, conforme as categorias avaliadas, deve ser rigorosamente bloqueada. Dentro de cada resultado, há informações detalhadas sobre as categorias de conteúdo analisadas e os scores associados a cada uma delas. Aqui estão as categorias e seus significados: sexual: conteúdo de natureza sexual explícita. hate: conteúdo que expressa ódio ou intolerância. harassment: conteúdo que constitui assédio ou intimidação. self-harm: conteúdo que promove ou encoraja danos a si mesmo. sexual/minors: conteúdo sexual envolvendo menores de idade. hate/threatening: conteúdo de ódio que inclui ameaças. violence/graphic: conteúdo violento ou gráfico. self-harm/intent: conteúdo que sugere intenção de se prejudicar. self-harm/instructions: conteúdo que fornece instruções sobre como se ferir. harassment/threatening: conteúdo de assédio que inclui ameaças. violence: conteúdo violento geral. Cada categoria possui um score que vai de 0 a 1, onde valores mais próximos de
DALL-E 2 Inpainting: Editando imagens com AI em .NET
Neste artigo exploraremos como integrar e integrar com a API de inpainting do DALL-E 2 usando .NET.
Transcrição de áudio com OpenAI Speech to Text e .NET
Aprenda a utilizar o serviço de Speech to Text da OpenAI para transcrever arquivos de áudio em suas aplicações .NET.