Skip to content

Open Source alternative to Algolia + Pinecone and an Easier-to-Use alternative to ElasticSearch ⚡ 🔍 ✨ Fast, typo tolerant, in-memory fuzzy Search Engine for building delightful search experiences

Move system_prompt and qa & add support for stoing conversation history and follow up

ozanarmagan589ac8747cb1
diff --git a/include/collection.h b/include/collection.h
index 45dd973d..198288cf 100644
--- a/include/collection.h
+++ b/include/collection.h
@@ -141,6 +141,8 @@ private:
// Keep index as the last field since it is initialized in the constructor via init_index(). Add a new field before it.
Index* index;
+ nlohmann::json qa;
+
// methods
std::string get_doc_id_key(const std::string & doc_id) const;
@@ -311,6 +313,8 @@ public:
static constexpr const char* REFERENCE_HELPER_FIELD_SUFFIX = "_sequence_id";
+ static constexpr const char* COLLECTION_QA = "qa";
+
// methods
Collection() = delete;
@@ -320,7 +324,7 @@ public:
const std::string& default_sorting_field,
const float max_memory_ratio, const std::string& fallback_field_type,
const std::vector<std::string>& symbols_to_index, const std::vector<std::string>& token_separators,
- const bool enable_nested_fields);
+ const bool enable_nested_fields, const nlohmann::json& qa);
~Collection();
@@ -479,7 +483,9 @@ public:
const size_t remote_embedding_num_tries = 2,
const std::string& stopwords_set="",
const std::vector<std::string>& facet_return_parent = {},
- const std::string& prompt = "") const;
+ const bool converstaion = false,
+ const std::string& system_prompt = "",
+ int conversation_id = -1) const;
Option<bool> get_filter_ids(const std::string & filter_query, filter_result_t& filter_result) const;
diff --git a/include/collection_manager.h b/include/collection_manager.h
index 99de5a8c..a9c66adf 100644
--- a/include/collection_manager.h
+++ b/include/collection_manager.h
@@ -155,7 +155,7 @@ public:
const std::string& fallback_field_type = "",
const std::vector<std::string>& symbols_to_index = {},
const std::vector<std::string>& token_separators = {},
- const bool enable_nested_fields = false);
+ const bool enable_nested_fields = false, const nlohmann::json& qa = nlohmann::json::object());
locked_resource_view_t<Collection> get_collection(const std::string & collection_name) const;
diff --git a/include/conversation_manager.h b/include/conversation_manager.h
new file mode 100644
index 00000000..1193691a
--- /dev/null
+++ b/include/conversation_manager.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <string>
+#include <unordered_map>
+#include <json.hpp>
+#include "option.h"
+
+
+class ConversationManager {
+ public:
+ ConversationManager() = delete;
+ static Option<int> create_conversation(const nlohmann::json& conversation);
+ static Option<nlohmann::json> get_conversation(int conversation_id);
+ static Option<bool> append_conversation(int conversation_id, const nlohmann::json& message);
+ private:
+ static inline std::unordered_map<int, nlohmann::json> conversations;
+ static inline int conversation_id = 0;
+};
\ No newline at end of file
diff --git a/include/field.h b/include/field.h
index 83790bb7..af54fd1a 100644
--- a/include/field.h
+++ b/include/field.h
@@ -90,7 +90,6 @@ struct field {
size_t num_dim;
nlohmann::json embed;
- nlohmann::json qa;
vector_distance_type_t vec_dist;
static constexpr int VAL_UNKNOWN = 2;
@@ -104,10 +103,10 @@ struct field {
field(const std::string &name, const std::string &type, const bool facet, const bool optional = false,
bool index = true, std::string locale = "", int sort = -1, int infix = -1, bool nested = false,
int nested_array = 0, size_t num_dim = 0, vector_distance_type_t vec_dist = cosine,
- std::string reference = "", const nlohmann::json& embed = nlohmann::json(),const nlohmann::json& qa = nlohmann::json(), const bool range_index = false) :
+ std::string reference = "", const nlohmann::json& embed = nlohmann::json(), const bool range_index = false) :
name(name), type(type), facet(facet), optional(optional), index(index), locale(locale),
nested(nested), nested_array(nested_array), num_dim(num_dim), vec_dist(vec_dist), reference(reference),
- embed(embed), range_index(range_index), qa(qa) {
+ embed(embed), range_index(range_index) {
set_computed_defaults(sort, infix);
}
diff --git a/include/qa_model.h b/include/qa_model.h
index 7f76a7de..058dd43d 100644
--- a/include/qa_model.h
+++ b/include/qa_model.h
@@ -5,10 +5,12 @@
#include "option.h"
+
class QAModel {
public:
virtual ~QAModel() {};
- static Option<std::string> get_answer(const std::string& context, const std::string& prompt, const nlohmann::json& model_config);
+ static Option<std::string> get_answer(const std::string& context, const std::string& prompt, const std::string& system_prompt, const nlohmann::json& model_config, int& conversation_id);
+ static Option<nlohmann::json> parse_conversation_history(const nlohmann::json& conversation, const nlohmann::json& model_config);
static Option<bool> validate_model(const nlohmann::json& model_config);
private:
};
@@ -16,8 +18,9 @@ class QAModel {
class OpenAIQAModel : public QAModel {
public:
- static Option<std::string> get_answer(const std::string& context, const std::string& prompt, const nlohmann::json& model_config);
+ static Option<std::string> get_answer(const std::string& context, const std::string& prompt, const std::string& system_prompt, const nlohmann::json& model_config, int& conversation_id);
static Option<bool> validate_model(const nlohmann::json& model_config);
+ static Option<nlohmann::json> parse_conversation_history(const nlohmann::json& conversation);
// prevent instantiation
OpenAIQAModel() = delete;
private:
diff --git a/src/collection.cpp b/src/collection.cpp
index f04792ee..de688001 100644
--- a/src/collection.cpp
+++ b/src/collection.cpp
@@ -19,7 +19,8 @@
#include "vector_query_ops.h"
#include "text_embedder_manager.h"
#include "stopwords_manager.h"
-#include "qa_model.h";
+#include "qa_model.h"
+#include "conversation_manager.h"
const std::string override_t::MATCH_EXACT = "exact";
const std::string override_t::MATCH_CONTAINS = "contains";
@@ -45,14 +46,14 @@ Collection::Collection(const std::string& name, const uint32_t collection_id, co
const float max_memory_ratio, const std::string& fallback_field_type,
const std::vector<std::string>& symbols_to_index,
const std::vector<std::string>& token_separators,
- const bool enable_nested_fields):
+ const bool enable_nested_fields, const nlohmann::json& qa):
name(name), collection_id(collection_id), created_at(created_at),
next_seq_id(next_seq_id), store(store),
fields(fields), default_sorting_field(default_sorting_field), enable_nested_fields(enable_nested_fields),
max_memory_ratio(max_memory_ratio),
fallback_field_type(fallback_field_type), dynamic_fields({}),
symbols_to_index(to_char_array(symbols_to_index)), token_separators(to_char_array(token_separators)),
- index(init_index()) {
+ index(init_index()), qa(qa) {
for (auto const& field: fields) {
if (field.embed.count(fields::from) != 0) {
@@ -242,7 +243,6 @@ nlohmann::json Collection::get_summary_json() const {
field_json[fields::sort] = coll_field.sort;
field_json[fields::infix] = coll_field.infix;
field_json[fields::locale] = coll_field.locale;
- field_json[fields::qa] = coll_field.qa;
if(coll_field.embed.count(fields::from) != 0) {
field_json[fields::embed] = coll_field.embed;
@@ -256,15 +256,6 @@ nlohmann::json Collection::get_summary_json() const {
}
}
- if(!coll_field.qa.empty()) {
- hide_credential(field_json[fields::qa], "api_key");
- hide_credential(field_json[fields::qa], "access_token");
- hide_credential(field_json[fields::qa], "refresh_token");
- hide_credential(field_json[fields::qa], "client_id");
- hide_credential(field_json[fields::qa], "client_secret");
- hide_credential(field_json[fields::qa], "project_id");
- }
-
if(coll_field.num_dim > 0) {
field_json[fields::num_dim] = coll_field.num_dim;
}
@@ -278,6 +269,13 @@ nlohmann::json Collection::get_summary_json() const {
json_response["fields"] = fields_arr;
json_response["default_sorting_field"] = default_sorting_field;
+ json_response["qa"] = qa;
+ hide_credential(json_response["qa"], "api_key");
+ hide_credential(json_response["qa"], "access_token");
+ hide_credential(json_response["qa"], "refresh_token");
+ hide_credential(json_response["qa"], "client_id");
+ hide_credential(json_response["qa"], "client_secret");
+ hide_credential(json_response["qa"], "project_id");
return json_response;
}
@@ -1132,7 +1130,9 @@ Option<nlohmann::json> Collection::search(std::string raw_query,
const size_t remote_embedding_num_tries,
const std::string& stopwords_set,
const std::vector<std::string>& facet_return_parent,
- const std::string& prompt) const {
+ const bool conversation,
+ const std::string& system_prompt,
+ int conversation_id) const {
std::shared_lock lock(mutex);
@@ -1305,8 +1305,18 @@ Option<nlohmann::json> Collection::search(std::string raw_query,
// Set query to * if it is semantic search
if(!vector_query.field_name.empty() && processed_search_fields.empty()) {
query = "*";
- } else if(!prompt.empty()) {
- return Option<nlohmann::json>(400, "Prompt is only supported for semantic search.");
+ }
+
+ if(conversation) {
+ if(vector_query.field_name.empty()) {
+ std::string error = "Conversation search is only supported for semantic and hybrid search.";
+ return Option<nlohmann::json>(400, error);
+ }
+
+ if(this->qa.empty()) {
+ std::string error = "Conversation search is not enabled for this collection.";
+ return Option<nlohmann::json>(400, error);
+ }
}
if(!vector_query.field_name.empty() && vector_query.values.empty() && num_embed_fields == 0) {
@@ -1967,7 +1977,7 @@ Option<nlohmann::json> Collection::search(std::string raw_query,
return Option<nlohmann::json>(prune_op.code(), prune_op.error());
}
- if(!prompt.empty()) {
+ if(conversation) {
docs_array.push_back(document);
}
@@ -2019,9 +2029,9 @@ Option<nlohmann::json> Collection::search(std::string raw_query,
}
}
- if(!prompt.empty()) {
+ if(conversation) {
result["qa"] = nlohmann::json::object();
- result["qa"]["prompt"] = prompt;
+ result["qa"]["query"] = raw_query;
auto embedding_field_it = search_schema.find(vector_query.field_name);
if(embedding_field_it == search_schema.end()) {
return Option<nlohmann::json>(400, "Invalid embedding field name.");
@@ -2031,11 +2041,31 @@ Option<nlohmann::json> Collection::search(std::string raw_query,
for(auto& doc : docs_array) {
doc.erase(embedding_field_it->name);
}
- auto qa_op = QAModel::get_answer(docs_array.dump(), prompt, embedding_field_it->qa);
+
+ bool has_conversation_history = conversation_id >= 0;
+ auto qa_op = QAModel::get_answer(docs_array.dump(), raw_query, system_prompt, this->qa, conversation_id);
if(!qa_op.ok()) {
return Option<nlohmann::json>(qa_op.code(), qa_op.error());
}
result["qa"]["answer"] = qa_op.get();
+ result["qa"]["system_prompt"] = system_prompt;
+ result["qa"]["conversation_id"] = conversation_id;
+
+ if(has_conversation_history) {
+ auto get_conversation_op = ConversationManager::get_conversation(conversation_id);
+ if(!get_conversation_op.ok()) {
+ return Option<nlohmann::json>(get_conversation_op.code(), get_conversation_op.error());
+ }
+
+ auto conversation_history = get_conversation_op.get();
+
+ auto parse_conversation_op = QAModel::parse_conversation_history(conversation_history, this->qa);
+ if(!parse_conversation_op.ok()) {
+ return Option<nlohmann::json>(parse_conversation_op.code(), parse_conversation_op.error());
+ }
+
+ result["qa"]["conversation_history"] = parse_conversation_op.get();
+ }
}
result["facet_counts"] = nlohmann::json::array();
@@ -4301,6 +4331,13 @@ Option<bool> Collection::validate_alter_payload(nlohmann::json& schema_changes,
return Option<bool>(400, "Only `fields` can be updated at the moment.");
}
+ if(schema_changes.count("qa") != 0) {
+ auto qa_op = QAModel::validate_model(schema_changes["qa"]);
+ if(!qa_op.ok()) {
+ return qa_op;
+ }
+ }
+
const std::string err_msg = "The `fields` value should be an array of objects containing "
"the field `name` and other properties.";
diff --git a/src/collection_manager.cpp b/src/collection_manager.cpp
index a7c0670b..664676f2 100644
--- a/src/collection_manager.cpp
+++ b/src/collection_manager.cpp
@@ -9,6 +9,7 @@
#include "logger.h"
#include "magic_enum.hpp"
#include "stopwords_manager.h"
+#include "qa_model.h"
constexpr const size_t CollectionManager::DEFAULT_NUM_MEMORY_SHARDS;
@@ -65,10 +66,6 @@ Collection* CollectionManager::init_collection(const nlohmann::json & collection
field_obj[fields::embed] = nlohmann::json::object();
}
- if(field_obj.count(fields::qa) == 0) {
- field_obj[fields::qa] = nlohmann::json::object();
- }
-
if(field_obj.count(fields::model_config) == 0) {
field_obj[fields::model_config] = nlohmann::json::object();
}
@@ -99,7 +96,7 @@ Collection* CollectionManager::init_collection(const nlohmann::json & collection
field f(field_obj[fields::name], field_obj[fields::type], field_obj[fields::facet],
field_obj[fields::optional], field_obj[fields::index], field_obj[fields::locale],
-1, field_obj[fields::infix], field_obj[fields::nested], field_obj[fields::nested_array],
- field_obj[fields::num_dim], vec_dist_type, field_obj[fields::reference], field_obj[fields::embed], field_obj[fields::qa]);
+ field_obj[fields::num_dim], vec_dist_type, field_obj[fields::reference], field_obj[fields::embed]);
// value of `sort` depends on field type
if(field_obj.count(fields::sort) == 0) {
@@ -131,6 +128,12 @@ Collection* CollectionManager::init_collection(const nlohmann::json & collection
std::vector<std::string> symbols_to_index;
std::vector<std::string> token_separators;
+ nlohmann::json qa = nlohmann::json::object();
+
+ if(collection_meta.count(Collection::COLLECTION_QA) != 0) {
+ qa = collection_meta[Collection::COLLECTION_QA];
+ }
+
if(collection_meta.count(Collection::COLLECTION_SYMBOLS_TO_INDEX) != 0) {
symbols_to_index = collection_meta[Collection::COLLECTION_SYMBOLS_TO_INDEX].get<std::vector<std::string>>();
}
@@ -152,7 +155,7 @@ Collection* CollectionManager::init_collection(const nlohmann::json & collection
fallback_field_type,
symbols_to_index,
token_separators,
- enable_nested_fields);
+ enable_nested_fields, qa);
return collection;
}
@@ -392,7 +395,8 @@ Option<Collection*> CollectionManager::create_collection(const std::string& name
const std::string& fallback_field_type,
const std::vector<std::string>& symbols_to_index,
const std::vector<std::string>& token_separators,
- const bool enable_nested_fields) {
+ const bool enable_nested_fields,
+ const nlohmann::json& qa) {
std::unique_lock lock(coll_create_mutex);
if(store->contains(Collection::get_meta_key(name))) {
@@ -426,12 +430,13 @@ Option<Collection*> CollectionManager::create_collection(const std::string& name
collection_meta[Collection::COLLECTION_SYMBOLS_TO_INDEX] = symbols_to_index;
collection_meta[Collection::COLLECTION_SEPARATORS] = token_separators;
collection_meta[Collection::COLLECTION_ENABLE_NESTED_FIELDS] = enable_nested_fields;
+ collection_meta[Collection::COLLECTION_QA] = qa;
Collection* new_collection = new Collection(name, next_collection_id, created_at, 0, store, fields,
default_sorting_field,
this->max_memory_ratio, fallback_field_type,
symbols_to_index, token_separators,
- enable_nested_fields);
+ enable_nested_fields, qa);
next_collection_id++;
rocksdb::WriteBatch batch;
@@ -812,8 +817,6 @@ Option<bool> CollectionManager::do_search(std::map<std::string, std::string>& re
const char *FACET_RETURN_PARENT = "facet_return_parent";
- const char *PROMPT = "prompt";
-
const char *VECTOR_QUERY = "vector_query";
const char* REMOTE_EMBEDDING_TIMEOUT_MS = "remote_embedding_timeout_ms";
@@ -870,6 +873,10 @@ Option<bool> CollectionManager::do_search(std::map<std::string, std::string>& re
const char *FACET_SAMPLE_PERCENT = "facet_sample_percent";
const char *FACET_SAMPLE_THRESHOLD = "facet_sample_threshold";
+ const char *CONVERSATION = "conversation";
+ const char *CONVERSATION_ID = "conversation_id";
+ const char *SYSTEM_PROMPT = "system_prompt";
+
// enrich params with values from embedded params
for(auto& item: embedded_params.items()) {
if(item.key() == "expires_at") {
@@ -984,11 +991,13 @@ Option<bool> CollectionManager::do_search(std::map<std::string, std::string>& re
size_t remote_embedding_timeout_ms = 5000;
size_t remote_embedding_num_tries = 2;
- std::string prompt;
-
size_t facet_sample_percent = 100;
size_t facet_sample_threshold = 0;
+ bool conversation = false;
+ size_t conversation_id = std::numeric_limits<size_t>::max();
+ std::string system_prompt;
+
std::unordered_map<std::string, size_t*> unsigned_int_values = {
{MIN_LEN_1TYPO, &min_len_1typo},
{MIN_LEN_2TYPO, &min_len_2typo},
@@ -1013,6 +1022,7 @@ Option<bool> CollectionManager::do_search(std::map<std::string, std::string>& re
{FACET_SAMPLE_THRESHOLD, &facet_sample_threshold},
{REMOTE_EMBEDDING_TIMEOUT_MS, &remote_embedding_timeout_ms},
{REMOTE_EMBEDDING_NUM_TRIES, &remote_embedding_num_tries},
+ {CONVERSATION_ID, &conversation_id},
};
std::unordered_map<std::string, std::string*> str_values = {
@@ -1025,7 +1035,7 @@ Option<bool> CollectionManager::do_search(std::map<std::string, std::string>& re
{HIGHLIGHT_END_TAG, &highlight_end_tag},
{PINNED_HITS, &pinned_hits_str},
{HIDDEN_HITS, &hidden_hits_str},
- {PROMPT, &prompt},
+ {SYSTEM_PROMPT, &system_prompt},
};
std::unordered_map<std::string, bool*> bool_values = {
@@ -1035,6 +1045,7 @@ Option<bool> CollectionManager::do_search(std::map<std::string, std::string>& re
{EXHAUSTIVE_SEARCH, &exhaustive_search},
{ENABLE_OVERRIDES, &enable_overrides},
{ENABLE_HIGHLIGHT_V1, &enable_highlight_v1},
+ {CONVERSATION, &conversation},
};
std::unordered_map<std::string, std::vector<std::string>*> str_list_values = {
@@ -1187,6 +1198,7 @@ Option<bool> CollectionManager::do_search(std::map<std::string, std::string>& re
Index::NUM_CANDIDATES_DEFAULT_MIN);
}
+
Option<nlohmann::json> result_op = collection->search(raw_query, search_fields, filter_query, facet_fields,
sort_fields, num_typos,
per_page,
@@ -1235,7 +1247,9 @@ Option<bool> CollectionManager::do_search(std::map<std::string, std::string>& re
remote_embedding_num_tries,
stopwords_set,
facet_return_parent,
- prompt
+ conversation,
+ system_prompt,
+ (conversation_id == std::numeric_limits<size_t>::max()) ? -1 : static_cast<int>(conversation_id)
);
uint64_t timeMillis = std::chrono::duration_cast<std::chrono::milliseconds>(
@@ -1394,6 +1408,15 @@ Option<Collection*> CollectionManager::create_collection(nlohmann::json& req_jso
return Option<Collection*>(parse_op.code(), parse_op.error());
}
+ if(req_json.count("qa") != 0) {
+ auto validate_qa_res = QAModel::validate_model(req_json["qa"]);
+ if(!validate_qa_res.ok()) {
+ return Option<Collection*>(validate_qa_res.code(), validate_qa_res.error());
+ }
+ } else {
+ req_json["qa"] = nlohmann::json::object();
+ }
+
const auto created_at = static_cast<uint64_t>(std::time(nullptr));
return CollectionManager::get_instance().create_collection(req_json["name"], num_memory_shards,
@@ -1401,7 +1424,7 @@ Option<Collection*> CollectionManager::create_collection(nlohmann::json& req_jso
fallback_field_type,
req_json[SYMBOLS_TO_INDEX],
req_json[TOKEN_SEPARATORS],
- req_json[ENABLE_NESTED_FIELDS]);
+ req_json[ENABLE_NESTED_FIELDS], req_json["qa"]);
}
Option<bool> CollectionManager::load_collection(const nlohmann::json &collection_meta,
diff --git a/src/conversation_manager.cpp b/src/conversation_manager.cpp
new file mode 100644
index 00000000..7f037e46
--- /dev/null
+++ b/src/conversation_manager.cpp
@@ -0,0 +1,41 @@
+#include "conversation_manager.h"
+
+
+Option<int> ConversationManager::create_conversation(const nlohmann::json& conversation) {
+ if(!conversation.is_array()) {
+ return Option<int>(400, "Conversation is not an array");
+ }
+
+ conversations[conversation_id] = conversation;
+ return Option<int>(conversation_id++);
+}
+
+Option<nlohmann::json> ConversationManager::get_conversation(int conversation_id) {
+ auto conversation = conversations.find(conversation_id);
+ if (conversation == conversations.end()) {
+ return Option<nlohmann::json>(400, "Conversation not found");
+ }
+
+ return Option<nlohmann::json>(conversation->second);
+}
+
+Option<bool> ConversationManager::append_conversation(int conversation_id, const nlohmann::json& message) {
+ auto conversation = conversations.find(conversation_id);
+ if (conversation == conversations.end()) {
+ return Option<bool>(400, "Conversation not found");
+ }
+
+ if(!conversation->second.is_array()) {
+ return Option<bool>(400, "Conversation is not an array");
+ }
+
+ if(!message.is_array()) {
+ conversation->second.push_back(message);
+ } else {
+ for(auto& m : message) {
+ conversation->second.push_back(m);
+ }
+ }
+
+ return Option<bool>(true);
+}
diff --git a/src/field.cpp b/src/field.cpp
index 948a4168..a56ce10d 100644
--- a/src/field.cpp
+++ b/src/field.cpp
@@ -279,29 +279,6 @@ Option<bool> field::json_field_to_field(bool enable_nested_fields, nlohmann::jso
}
}
- if(field_json.count(fields::qa) != 0) {
- if(field_json.count(fields::embed) == 0 || !field_json[fields::embed].is_object() || field_json[fields::embed].count(fields::from) == 0) {
- return Option<bool>(400, "Property `" + fields::qa + "` is allowed only on an embedded field.");
- }
-
- // qa object should contain "model_name" and it should be a string
- if(!field_json[fields::qa].is_object() || field_json[fields::qa].count(fields::model_name) == 0 ||
- !field_json[fields::qa][fields::model_name].is_string()) {
- return Option<bool>(400, "Property `" + fields::qa + "` should be an object containing a `model_name` property.");
- }
-
- // it may contain "system_prompt", if exists it should be a string
- if(field_json[fields::qa].count(fields::system_prompt) != 0 && !field_json[fields::qa][fields::system_prompt].is_string()) {
- return Option<bool>(400, "`qa.system_prompt` should be a string.");
- }
-
- auto validate_qa_res = QAModel::validate_model(field_json[fields::qa]);
- if(!validate_qa_res.ok()) {
- return validate_qa_res;
- }
- }
-
-
if(field_json.count(fields::optional) == 0) {
// dynamic type fields are always optional
bool is_dynamic = field::is_dynamic(field_json[fields::name], field_json[fields::type]);
@@ -345,7 +322,7 @@ Option<bool> field::json_field_to_field(bool enable_nested_fields, nlohmann::jso
field_json[fields::optional], field_json[fields::index], field_json[fields::locale],
field_json[fields::sort], field_json[fields::infix], field_json[fields::nested],
field_json[fields::nested_array], field_json[fields::num_dim], vec_dist,
- field_json[fields::reference], field_json[fields::embed], field_json[fields::qa], field_json[fields::range_index])
+ field_json[fields::reference], field_json[fields::embed], field_json[fields::range_index])
);
if (!field_json[fields::reference].get<std::string>().empty()) {
diff --git a/src/qa_model.cpp b/src/qa_model.cpp
index 3f688011..d9a73d73 100644
--- a/src/qa_model.cpp
+++ b/src/qa_model.cpp
@@ -1,9 +1,15 @@
#include "qa_model.h"
#include "text_embedder_manager.h"
#include "text_embedder_remote.h"
+#include "conversation_manager.h"
Option<bool> QAModel::validate_model(const nlohmann::json& model_config) {
+ // check model_name is exists and it is a string
+ if(model_config.count("model_name") == 0 || !model_config["model_name"].is_string()) {
+ return Option<bool>(400, "Property `qa.model_name` is not provided or not a string.");
+ }
+
const std::string model_namespace = TextEmbedderManager::get_model_namespace(model_config["model_name"].get<std::string>());
if(model_namespace == "openai") {
return OpenAIQAModel::validate_model(model_config);
@@ -12,21 +18,36 @@ Option<bool> QAModel::validate_model(const nlohmann::json& model_config) {
return Option<bool>(400, "Model namespace `" + model_namespace + "` is not supported.");
}
-Option<std::string> QAModel::get_answer(const std::string& context, const std::string& prompt, const nlohmann::json& model_config) {
+Option<std::string> QAModel::get_answer(const std::string& context, const std::string& prompt,
+ const std::string& system_prompt, const nlohmann::json& model_config, int& conversation_id) {
const std::string model_namespace = TextEmbedderManager::get_model_namespace(model_config["model_name"].get<std::string>());
if(model_namespace == "openai") {
- return OpenAIQAModel::get_answer(context, prompt, model_config);
+ return OpenAIQAModel::get_answer(context, prompt, system_prompt, model_config, conversation_id);
}
throw Option<std::string>(400, "Model namespace " + model_namespace + " is not supported.");
}
+Option<nlohmann::json> QAModel::parse_conversation_history(const nlohmann::json& conversation, const nlohmann::json& model_config) {
+ const std::string model_namespace = TextEmbedderManager::get_model_namespace(model_config["model_name"].get<std::string>());
+
+ if(model_namespace == "openai") {
+ return OpenAIQAModel::parse_conversation_history(conversation);
+ }
+
+ throw Option<nlohmann::json>(400, "Model namespace " + model_namespace + " is not supported.");
+}
+
Option<bool> OpenAIQAModel::validate_model(const nlohmann::json& model_config) {
if(model_config.count("api_key") == 0) {
return Option<bool>(400, "API key is not provided");
}
+
+ if(!model_config["api_key"].is_string()) {
+ return Option<bool>(400, "API key is not a string");
+ }
std::unordered_map<std::string, std::string> headers;
std::map<std::string, std::string> res_headers;
@@ -104,7 +125,8 @@ Option<bool> OpenAIQAModel::validate_model(const nlohmann::json& model_config) {
return Option<bool>(true);
}
-Option<std::string> OpenAIQAModel::get_answer(const std::string& context, const std::string& prompt, const nlohmann::json& model_config) {
+Option<std::string> OpenAIQAModel::get_answer(const std::string& context, const std::string& prompt,
+ const std::string& system_prompt, const nlohmann::json& model_config, int& conversation_id) {
const std::string model_name = TextEmbedderManager::get_model_name_without_namespace(model_config["model_name"].get<std::string>());
const std::string api_key = model_config["api_key"].get<std::string>();
std::unordered_map<std::string, std::string> headers;
@@ -114,16 +136,38 @@ Option<std::string> OpenAIQAModel::get_answer(const std::string& context, const
nlohmann::json req_body;
req_body["model"] = model_name;
req_body["messages"] = nlohmann::json::array();
- if(model_config.count("system_prompt") != 0) {
+
+ nlohmann::json current_conversation = nlohmann::json::array();
+ if(!system_prompt.empty()) {
nlohmann::json system_message = nlohmann::json::object();
system_message["role"] = "system";
- system_message["content"] = model_config["system_prompt"].get<std::string>();
- req_body["messages"].push_back(system_message);
+ system_message["content"] = system_prompt;
+ current_conversation.push_back(system_message);
+ }
+
+ if(conversation_id < 0) {
+ nlohmann::json message = nlohmann::json::object();
+ message["role"] = "user";
+ message["content"] = "Data:\n" + context + "\n\nQuestion:\n" + prompt;
+ current_conversation.push_back(message);
+ req_body["messages"] = current_conversation;
+ } else {
+ auto conversation_history_op = ConversationManager::get_conversation(conversation_id);
+ if(!conversation_history_op.ok()) {
+ return Option<std::string>(conversation_history_op.code(), conversation_history_op.error());
+ }
+
+ auto conversation_history = conversation_history_op.get();
+ req_body["messages"] = conversation_history;
+ nlohmann::json message = nlohmann::json::object();
+ message["role"] = "user";
+ message["content"] = prompt;
+ if(current_conversation.size() > 0) {
+ req_body["messages"].push_back(current_conversation[0]);
+ }
+ current_conversation.push_back(message);
+ req_body["messages"].push_back(message);
}
- nlohmann::json message = nlohmann::json::object();
- message["role"] = "user";
- message["content"] = "Data:\n" + context + "\n\nQuestion:\n" + prompt;
- req_body["messages"].push_back(message);
std::string res;
auto res_code = RemoteEmbedder::call_remote_api("POST", OPENAI_CHAT_COMPLETION, req_body.dump(), res, res_headers, headers);
@@ -152,5 +196,50 @@ Option<std::string> OpenAIQAModel::get_answer(const std::string& context, const
throw Option<std::string>(400, "Got malformed response from OpenAI API.");
}
+
+ current_conversation.push_back(json_res["choices"][0]["message"]);
+ if(conversation_id < 0) {
+ auto conversation_id_op = ConversationManager::create_conversation(current_conversation);
+ if(!conversation_id_op.ok()) {
+ return Option<std::string>(conversation_id_op.code(), conversation_id_op.error());
+ }
+
+ conversation_id = conversation_id_op.get();
+ } else {
+ auto append_conversation_op = ConversationManager::append_conversation(conversation_id, current_conversation);
+ if(!append_conversation_op.ok()) {
+ return Option<std::string>(append_conversation_op.code(), append_conversation_op.error());
+ }
+ }
+
return Option<std::string>(json_res["choices"][0]["message"]["content"].get<std::string>());
+}
+
+Option<nlohmann::json> OpenAIQAModel::parse_conversation_history(const nlohmann::json& conversation) {
+ if(!conversation.is_array()) {
+ return Option<nlohmann::json>(400, "Conversation is not an array");
+ }
+
+ nlohmann::json messages = nlohmann::json::array();
+ for(auto& message : conversation) {
+ if(!message.is_object()) {
+ return Option<nlohmann::json>(400, "Message is not an object");
+ }
+
+ if(message.count("role") == 0 || !message["role"].is_string()) {
+ return Option<nlohmann::json>(400, "Message role is not provided or not a string");
+ }
+
+ if(message.count("content") == 0 || !message["content"].is_string()) {
+ return Option<nlohmann::json>(400, "Message content is not provided or not a string");
+ }
+
+ auto parsed_message = nlohmann::json::object();
+ parsed_message[message["role"].get<std::string>()] = message["content"].get<std::string>();
+ messages.push_back(parsed_message);
+ }
+
+
+
+ return Option<nlohmann::json>(messages);
}
\ No newline at end of file