public String analyzeEmailWithChatAPI(String emailContent, String prompt) {

    String url = "https://api.openai.com/v1/chat/completions";

    

    HttpHeaders headers = new HttpHeaders();

    headers.setBearerAuth(openAiApiKey);

    headers.setContentType(MediaType.APPLICATION_JSON);

    // Load system prompt

    String systemPrompt = prompt != null ? prompt : loadPromptFromFile();

    // Construct messages

    List<Map<String, String>> messages = List.of(

        Map.of("role", "system", "content", systemPrompt),

        Map.of("role", "user", "content", 

            "Here is the email to process:\n\"\"\"\n" + emailContent + "\n\"\"\"")

    );

    Map<String, Object> body = Map.of(

        "model", "gpt-4",

        "messages", messages,

        "temperature", 0  // Deterministic output

    );

    HttpEntity<Map<String, Object>> request = new HttpEntity<>(body, headers);

    RestTemplate restTemplate = factory.createRestTemplate();

    try {

        ResponseEntity<String> response = 

            restTemplate.postForEntity(url, request, String.class);

        return response.getBody();

    } catch (Exception e) {

        logger.error("Error calling OpenAI API: {}", e.getMessage());

        return null;

    }

}

[

  {

    "assetType": "Bank Accounts",

    "institutionName": "Chase Bank",

    "accountNumber": "XXXX1234",

    "website": "chase.com"

  }

]

@Async

public CompletableFuture<List<Asset>> processBatchAsync(List<Email> emails) {

    int batchSize = 10;  // Process 10 emails per batch

    List<CompletableFuture<List<Asset>>> futures = new ArrayList<>();

    

    for (int i = 0; i < emails.size(); i += batchSize) {

        List<Email> batch = emails.subList(

            i, 

            Math.min(i + batchSize, emails.size())

        );

        

        // Process each batch in parallel

        futures.add(CompletableFuture.supplyAsync(() -> 

            processBatch(batch), taskExecutor

        ));

    }

    

    // Wait for all batches to complete

    CompletableFuture.allOf(

        futures.toArray(new CompletableFuture[0])

    ).join();

    

    // Merge results from all batches

    return CompletableFuture.completedFuture(

        futures.stream()

            .map(CompletableFuture::join)

            .flatMap(List::stream)

            .collect(Collectors.toList())

    );

}

private List<Asset> processBatch(List<Email> batch) {

    // Combine multiple emails into one API call

    String combinedContent = batch.stream()

        .map(this::formatEmailForBatch)

        .collect(Collectors.joining("\n---\n"));

    

    String response = analyzeEmailWithChatAPI(combinedContent, systemPrompt);

    return parseAssetsFromResponse(response);

}