Extracting Information from PDFs Using OpenAI Assistants API in R

To extract specific information from large PDFs using the OpenAI API in R, you'll need to follow these steps:

Overview of the Process

1. Upload each PDF file to OpenAI
2. Create an Assistant with appropriate instructions
3. Create a Thread with the file attached
4. Run the Assistant to extract information
5. Retrieve the response as a structured dictionary

Implementation in R

First, you'll need to install and load the necessary packages:

RCopied
install.packages(c("httr", "jsonlite"))
library(httr)
library(jsonlite)

Step 1: Set up your API key

RCopied
openai_api_key <- Sys.getenv("OPENAI_API_KEY")

Step 2: Function to upload a PDF file

RCopied
upload_file <- function(file_path) {
  response <- POST(
    url = "https://api.openai.com/v1/files",
    add_headers(
      "Authorization" = paste("Bearer", openai_api_key),
      "Content-Type" = "multipart/form-data"
    ),
    body = list(
      file = upload_file(file_path),
      purpose = "assistants"
    ),
    encode = "multipart"
  )
  
  content <- content(response, "parsed")
  return(content$id)
}

Step 3: Create an Assistant

RCopied
create_assistant <- function() {
  response <- POST(
    url = "https://api.openai.com/v1/assistants",
    add_headers(
      "Authorization" = paste("Bearer", openai_api_key),
      "Content-Type" = "application/json",
      "OpenAI-Beta" = "assistants=v2"
    ),
    body = toJSON(list(
      model = "gpt-4o",
      name = "PDF Information Extractor",
      instructions = "Extract the following information from the PDF: [SPECIFY YOUR EXTRACTION REQUIREMENTS HERE]. Return the information as a structured JSON dictionary with the following keys: [SPECIFY YOUR KEYS HERE]. Be precise and only extract the requested information.",
      tools = list(list(type = "retrieval"))
    ), auto_unbox = TRUE),
    encode = "json"
  )
  
  content <- content(response, "parsed")
  return(content$id)
}

Step 4: Process each PDF and extract information

RCopied
extract_info_from_pdf <- function(pdf_path, assistant_id) {
  # Upload the file
  file_id <- upload_file(pdf_path)
  
  # Create a thread with the file
  thread_response <- POST(
    url = "https://api.openai.com/v1/threads",
    add_headers(
      "Authorization" = paste("Bearer", openai_api_key),
      "Content-Type" = "application/json",
      "OpenAI-Beta" = "assistants=v2"
    ),
    body = toJSON(list(
      messages = list(
        list(
          role = "user",
          content = "Please extract the required information from this PDF and return it as a structured dictionary.",
          file_ids = list(file_id)
        )
      )
    ), auto_unbox = TRUE),
    encode = "json"
  )
  
  thread_content <- content(thread_response, "parsed")
  thread_id <- thread_content$id
  
  # Run the assistant on the thread
  run_response <- POST(
    url = paste0("https://api.openai.com/v1/threads/", thread_id, "/runs"),
    add_headers(
      "Authorization" = paste("Bearer", openai_api_key),
      "Content-Type" = "application/json",
      "OpenAI-Beta" = "assistants=v2"
    ),
    body = toJSON(list(
      assistant_id = assistant_id
    ), auto_unbox = TRUE),
    encode = "json"
  )
  
  run_content <- content(run_response, "parsed")
  run_id <- run_content$id
  
  # Poll for completion
  status <- "queued"
  while (status %in% c("queued", "in_progress")) {
    Sys.sleep(2)  # Wait for 2 seconds before checking again
    
    check_response <- GET(
      url = paste0("https://api.openai.com/v1/threads/", thread_id, "/runs/", run_id),
      add_headers(
        "Authorization" = paste("Bearer", openai_api_key),
        "OpenAI-Beta" = "assistants=v2"
      )
    )
    
    check_content <- content(check_response, "parsed")
    status <- check_content$status
  }
  
  # Get the messages (results)
  if (status == "completed") {
    messages_response <- GET(
      url = paste0("https://api.openai.com/v1/threads/", thread_id, "/messages"),
      add_headers(
        "Authorization" = paste("Bearer", openai_api_key),
        "OpenAI-Beta" = "assistants=v2"
      )
    )
    
    messages_content <- content(messages_response, "parsed")
    
    # Get the assistant's response (should be the last message)
    assistant_message <- messages_content$data[[1]]
    
    # Parse the JSON response to get the dictionary
    extracted_info <- fromJSON(assistant_message$content[[1]]$text$value)
    return(extracted_info)
  } else {
    return(paste("Run failed with status:", status))
  }
}

Step 5: Process multiple PDFs

RCopied
process_multiple_pdfs <- function(pdf_paths) {
  # Create an assistant once
  assistant_id <- create_assistant()
  
  # Process each PDF
  results <- list()
  for (i in seq_along(pdf_paths)) {
    pdf_path <- pdf_paths[i]
    pdf_name <- basename(pdf_path)
    
    cat("Processing", pdf_name, "...\n")
    result <- extract_info_from_pdf(pdf_path, assistant_id)
    
    results[[pdf_name]] <- result
  }
  
  return(results)
}

# Example usage
pdf_paths <- c("path/to/pdf1.pdf", "path/to/pdf2.pdf", "path/to/pdf3.pdf")
extracted_data <- process_multiple_pdfs(pdf_paths)

# Save results to a JSON file
write_json(extracted_data, "extracted_information.json", pretty = TRUE)

Important Notes

1. Make sure to customize the assistant instructions to specify exactly what information you want to extract from each PDF.

2. The response format should be specified in the instructions to ensure you get a consistent dictionary structure.

3. For very large PDFs, the API might have limitations. Consider splitting them if necessary.

4. This implementation includes polling to wait for the assistant to complete processing, which is necessary for asynchronous operations.

5. Error handling should be added for production use to manage API rate limits and potential failures.

6. You may need to adjust the waiting time between status checks depending on the size of your PDFs.

This approach leverages OpenAI's Assistants API which is specifically designed for this kind of task, making it more efficient than using the standard completion API.