information-retrieval

main.cpp (6307B)

---

 #include <cpr/cpr.h>
 #include <ctime>
 #include "../include/openai.hpp"
 #include <vector>
 #include <iostream>
 #include "../include/nlohmann/json.hpp"
 #include "prompts.cpp"
 
 struct SearchResult{
     std::string url;
     std::string title;
     std::string content;
     float score;
 };
 
 nlohmann::json sendUserMessage(openai::OpenAI* connection , std::string model, std::string message){
     nlohmann::json payload = {
         {"model", model},
         {"messages", {{{"role", "user"}, {"content", message}}}},
         {"temperature", 0}
     };
 
     auto chat = connection->chat.create(
         payload
     );
     return chat;
 }
 
 std::string getMessageFromChat(nlohmann::json json){
     std::string result = json["choices"][0]["message"]["content"].dump(2);
     return result;
 }
 
 std::string getResearcherPrompt(){
     std::string returnStr(researchPrompt);
 
     std::time_t t = std::time(nullptr);
     std::tm* now = std::localtime(&t);
     std::string dateReplacement = std::to_string(now->tm_mon + 1) + "-" 
                                 + std::to_string(now->tm_mday) + "-" 
                                 + std::to_string(now->tm_year + 1900);
     std::string toReplace = "$DATE";
 
     std::size_t dateLocation = returnStr.find(toReplace);
     returnStr.replace(dateLocation, toReplace.length(), dateReplacement);
 
     return returnStr;
 }
 
 
 std::vector<std::pair<std::string, std::string>> parseToolCalls(std::string response){
 
     std::vector<std::string> rawToolCalls;
 
     std::stringstream ss(response);
     std::string line;
 
     while (getline(ss, line)) {
         if (!line.empty()) {
             rawToolCalls.push_back(line);
         }
     }
 
 
     auto pairs = std::vector<std::pair<std::string, std::string>>();
 
     for(int i = 0 ; i < rawToolCalls.size(); ++i){
         
         std::string current = rawToolCalls[i];
 
         int space = current.find(' ');
         int parenthesis = current.find('(');
 
         std::string toolcall;
         std::string remaining;
 
 
         // TODO: Do prefix matching
         if (space != std::string::npos){
             toolcall = current.substr(1, space - 1);
             std::string unclean = current.substr(space + 1, current.size() - space - 2);
             for (size_t i = 0; i < unclean.size(); ++i) {
                 if (unclean[i] == '\\' && i + 1 < unclean.size() && unclean[i + 1] == '"') {
                     continue;
                 }
                 remaining += unclean[i];
             }
             
         }
         else {
             toolcall = "done";
         }
 
         auto pair = std::pair(toolcall, remaining);
         pairs.push_back(pair);
     }
     return pairs;
 }
 
 
 
 // I hate cpr.
 std::vector<SearchResult> searchSearxng(std::string url, std::string query){
 
     std::vector<SearchResult> returnValues;
 
     cpr::Response r = cpr::Get(
         cpr::Url{url + "/search"},
         cpr::Parameters{{"q", query}, {"format", "json"}}
     );
     // TODO: Check status code
     //std::cout << r.status_code << std::endl;
     //std::cout << r.text << std::endl;
 
     nlohmann::json currentJson = nlohmann::json::parse(r.text);
     nlohmann::json results = currentJson["results"];
 
     for (int i = 0 ; i < results.size(); ++i){
         auto currentResult = SearchResult();
         currentResult.url = results[i]["url"].get<std::string>();
         currentResult.content= results[i]["content"].get<std::string>();
         currentResult.score = results[i]["score"].get<float>();
         currentResult.title = results[i]["title"].get<std::string>();
         returnValues.push_back(currentResult);
     }
 
     return returnValues;
 }
 
 int main(int argc, char* argv[]) {
 
 
     openai::start();
     openai::OpenAI connection = openai::OpenAI();
 
     std::string envVariable = "ANTHROPIC_API_KEY";
     std::string model = "claude-opus-4-5-20251101";
     std::string baseURL = "https://api.anthropic.com/v1/";
     std::string priorRuns = "";
     int linkNum = 1;
 
     connection.setToken(getenv(envVariable.c_str()));
     connection.setBaseUrl(baseURL);
 
     std::string chatMessage;
     if(argc == 2){
         chatMessage = argv[1];
     }
     else{
         std::getline(std::cin, chatMessage);
     }
 
     while(true){
         std::vector<std::pair<std::string, std::string>> toolCallsAndParams;
         std::string message;
 
         std::string prompt = getResearcherPrompt();
         message = prompt + chatMessage;
 
         nlohmann::json response = sendUserMessage(&connection, model, priorRuns + message);
         toolCallsAndParams = parseToolCalls(getMessageFromChat(response));
 
 
         for(int i = 0 ; i < toolCallsAndParams.size(); ++i){
             std::pair<std::string, std::string> current = toolCallsAndParams[i];
             if(current.first.compare("web_search") == 0){
                 //std::cout << current.second << std::endl;
                 std::vector<std::string> params = nlohmann::json::parse(current.second).get<std::vector<std::string>>();
                 for(int i = 0 ; i < params.size(); ++i){
                     std::cout << "Searching the web for " << params[i] << std::endl;
                     //std::cout << params[i] << std::endl;
                     // TODO: add citations
                     std::vector<SearchResult> searchRes = searchSearxng("https://searx.laack.co", params[i]);
 
                     priorRuns += "Searching for " + params[i];
                     for (int i = 0 ; i < searchRes.size(); ++i){
                         priorRuns += "Results from " + searchRes[i].url + " [" + std::to_string(linkNum) + "]:\n" + searchRes[i].content + "\n";
                         linkNum += 1;
                     }
                 }
             }
             else{
                 if(current.first == "done"){
                     // TODO: Add a final summarization prompt
                     std::string summary = "Consider the above context, and use it to answer the following question:";
                     std::string final = "\n Ensure your final answer makes extensive references to resources with [1] syntax.";
 
                     nlohmann::json response = sendUserMessage(&connection, model, priorRuns + summary + chatMessage + final);
                     std::cout << getMessageFromChat(response) << std::endl;
                     return 0;
                 }
             }
         }
     }
 }