Analisando PDFs com a OpenAI - Next Wave Education

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<string> 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<string> PerguntarSobreOArquivo(string prompt, string fileId)
{
    var json = JsonSerializer.Serialize(new
    {
        model = "gpt-4.1",
        input = new[]
            {
                new
                {
                    role = "user",
                    content = new List<object>
                    {
                        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”. O tipo de conteúdo (Content-Type) é definido como “application/json”, informando à OpenAI que estamos enviando dados em formato JSON.

				
					client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}");

A seguir, limpamos qualquer cabeçalho de requisição anterior e configuramos o cabeçalho “Authorization” com o token da API.

				
					var response = await client.PostAsync(urlBase, requestBody);

Agora, a requisição é enviada usando o método “PostAsync”.

				
					if (response.IsSuccessStatusCode)
{
    var responseContent = await response.Content.ReadAsStringAsync();

Após enviar a requisição, verificamos se a resposta da API foi bem-sucedida com “response.IsSuccessStatusCode”. Se a requisição for bem-sucedida, lemos o conteúdo da resposta.

				
					using (JsonDocument doc = JsonDocument.Parse(responseContent))
{
    var text = doc.RootElement
                   .GetProperty("output")[0]
                   .GetProperty("content")[0]
                   .GetProperty("text")
                   .GetString();

    return text;
}

No código acima, utilizamos o “JsonDocument” para acessar o campo do json que contém o texto com a resposta. A resposta devolvida pela OpenAI contém diversos campos, mas para apresentar a resposta ao usuário vamos usar apenas o campo “text”.

Por fim, finalizamos o nosso código fechando a condicional com o “else” em caso de respostas negativas vinda da API:

				
					 }
            else
            {
                return "Erro ao processar o arquivo: " + response.ReasonPhrase;
            }
        }
    }
}

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

Usar arquivos PDF como entrada para os modelos da OpenAI oferece um enorme potencial para automatizar a análise de documentos e obter respostas baseadas em conteúdo textual e visual. Com o método de upload, você pode integrar facilmente arquivos PDF às suas aplicações, tornando mais simples a extração de informações de documentos complexos.