mirror of https://github.com/sysown/proxysql
- Rename NL2SQL_Converter to LLM_Bridge for generic prompt processing - Update MySQL protocol handler from /* NL2SQL: */ to /* LLM: */ - Remove SQL-specific fields (sql_query, confidence, tables_used) - Add GENAI_OP_LLM operation type to GenAI module - Rename all genai_nl2sql_* variables to genai_llm_* - Update AI_Features_Manager to use LLM_Bridge - Deprecate ai_nl2sql_convert MCP tool with error message - LLM bridge now handles any prompt type via MySQL protocol This enables generic LLM access (summarization, code generation, translation, analysis) while preserving infrastructure for future NL2SQL implementation via Web UI + external agents.pull/5310/head
Rene Cannao
5 months ago
parent
3fe8a48f70
commit
a3f0bade4e
@ -0,0 +1,375 @@
|
||||
/**
|
||||
* @file LLM_Bridge.cpp
|
||||
* @brief Implementation of Generic LLM Bridge
|
||||
*
|
||||
* This file implements the generic LLM bridge pipeline including:
|
||||
* - Vector cache operations for semantic similarity
|
||||
* - Model selection based on latency/budget
|
||||
* - Generic LLM API calls (Ollama, OpenAI-compatible, Anthropic-compatible)
|
||||
*
|
||||
* @see LLM_Bridge.h
|
||||
*/
|
||||
|
||||
#include "LLM_Bridge.h"
|
||||
#include "sqlite3db.h"
|
||||
#include "proxysql_utils.h"
|
||||
#include "GenAI_Thread.h"
|
||||
#include "cpp.h"
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <sstream>
|
||||
#include <algorithm>
|
||||
#include <regex>
|
||||
#include <chrono>
|
||||
|
||||
using json = nlohmann::json;
|
||||
|
||||
// Global GenAI handler for embedding generation
|
||||
extern GenAI_Threads_Handler *GloGATH;
|
||||
|
||||
// Global AI Features Manager for status updates
|
||||
extern AI_Features_Manager *GloAI;
|
||||
|
||||
// ============================================================================
|
||||
// Error Handling Helper Functions
|
||||
// ============================================================================
|
||||
|
||||
/**
|
||||
* @brief Convert error code enum to string representation
|
||||
*/
|
||||
const char* llm_error_code_to_string(LLMErrorCode code) {
|
||||
switch (code) {
|
||||
case LLMErrorCode::SUCCESS: return "SUCCESS";
|
||||
case LLMErrorCode::ERR_API_KEY_MISSING: return "ERR_API_KEY_MISSING";
|
||||
case LLMErrorCode::ERR_API_KEY_INVALID: return "ERR_API_KEY_INVALID";
|
||||
case LLMErrorCode::ERR_TIMEOUT: return "ERR_TIMEOUT";
|
||||
case LLMErrorCode::ERR_CONNECTION_FAILED: return "ERR_CONNECTION_FAILED";
|
||||
case LLMErrorCode::ERR_RATE_LIMITED: return "ERR_RATE_LIMITED";
|
||||
case LLMErrorCode::ERR_SERVER_ERROR: return "ERR_SERVER_ERROR";
|
||||
case LLMErrorCode::ERR_EMPTY_RESPONSE: return "ERR_EMPTY_RESPONSE";
|
||||
case LLMErrorCode::ERR_INVALID_RESPONSE: return "ERR_INVALID_RESPONSE";
|
||||
case LLMErrorCode::ERR_VALIDATION_FAILED: return "ERR_VALIDATION_FAILED";
|
||||
case LLMErrorCode::ERR_UNKNOWN_PROVIDER: return "ERR_UNKNOWN_PROVIDER";
|
||||
case LLMErrorCode::ERR_REQUEST_TOO_LARGE: return "ERR_REQUEST_TOO_LARGE";
|
||||
default: return "UNKNOWN";
|
||||
}
|
||||
}
|
||||
|
||||
// Forward declarations of external functions from LLM_Clients.cpp
|
||||
extern std::string call_generic_openai_with_retry(const std::string& prompt, const std::string& model,
|
||||
const std::string& url, const char* key,
|
||||
const std::string& req_id);
|
||||
extern std::string call_generic_anthropic_with_retry(const std::string& prompt, const std::string& model,
|
||||
const std::string& url, const char* key,
|
||||
const std::string& req_id);
|
||||
|
||||
// ============================================================================
|
||||
// LLM_Bridge Implementation
|
||||
// ============================================================================
|
||||
|
||||
/**
|
||||
* @brief Constructor - initializes with default configuration
|
||||
*/
|
||||
LLM_Bridge::LLM_Bridge()
|
||||
: vector_db(nullptr)
|
||||
{
|
||||
// Set default configuration
|
||||
config.enabled = false;
|
||||
config.provider = strdup("openai");
|
||||
config.provider_url = strdup("http://localhost:11434/v1/chat/completions");
|
||||
config.provider_model = strdup("llama3.2");
|
||||
config.provider_key = nullptr;
|
||||
config.cache_similarity_threshold = 85;
|
||||
config.timeout_ms = 30000;
|
||||
|
||||
proxy_debug(PROXY_DEBUG_GENAI, 3, "LLM_Bridge: Initialized with defaults\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Destructor - frees allocated resources
|
||||
*/
|
||||
LLM_Bridge::~LLM_Bridge() {
|
||||
if (config.provider) free(config.provider);
|
||||
if (config.provider_url) free(config.provider_url);
|
||||
if (config.provider_model) free(config.provider_model);
|
||||
if (config.provider_key) free(config.provider_key);
|
||||
|
||||
proxy_debug(PROXY_DEBUG_GENAI, 3, "LLM_Bridge: Destroyed\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Initialize the LLM bridge
|
||||
*/
|
||||
int LLM_Bridge::init() {
|
||||
proxy_info("LLM_Bridge: Initialized successfully\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Shutdown the LLM bridge
|
||||
*/
|
||||
void LLM_Bridge::close() {
|
||||
proxy_info("LLM_Bridge: Shutdown complete\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Update configuration from AI_Features_Manager
|
||||
*/
|
||||
void LLM_Bridge::update_config(const char* provider, const char* provider_url, const char* provider_model,
|
||||
const char* provider_key, int cache_threshold, int timeout) {
|
||||
if (provider) {
|
||||
if (config.provider) free(config.provider);
|
||||
config.provider = strdup(provider);
|
||||
}
|
||||
if (provider_url) {
|
||||
if (config.provider_url) free(config.provider_url);
|
||||
config.provider_url = strdup(provider_url);
|
||||
}
|
||||
if (provider_model) {
|
||||
if (config.provider_model) free(config.provider_model);
|
||||
config.provider_model = strdup(provider_model);
|
||||
}
|
||||
if (provider_key) {
|
||||
if (config.provider_key) free(config.provider_key);
|
||||
config.provider_key = provider_key ? strdup(provider_key) : nullptr;
|
||||
}
|
||||
config.cache_similarity_threshold = cache_threshold;
|
||||
config.timeout_ms = timeout;
|
||||
|
||||
proxy_debug(PROXY_DEBUG_GENAI, 3, "LLM_Bridge: Configuration updated\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Build prompt from request
|
||||
*/
|
||||
std::string LLM_Bridge::build_prompt(const LLMRequest& req) {
|
||||
std::string prompt = req.prompt;
|
||||
|
||||
// Add system message if provided
|
||||
if (!req.system_message.empty()) {
|
||||
// For most LLM APIs, the system message is handled separately
|
||||
// This is a simplified implementation
|
||||
}
|
||||
|
||||
return prompt;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Check vector cache for similar prompts
|
||||
*/
|
||||
LLMResult LLM_Bridge::check_cache(const LLMRequest& req) {
|
||||
LLMResult result;
|
||||
result.cached = false;
|
||||
result.cache_hit = false;
|
||||
|
||||
if (!vector_db || !req.allow_cache) {
|
||||
return result;
|
||||
}
|
||||
|
||||
auto start_time = std::chrono::high_resolution_clock::now();
|
||||
|
||||
// TODO: Implement vector similarity search
|
||||
// This would involve:
|
||||
// 1. Generate embedding for the prompt
|
||||
// 2. Search vector database for similar prompts
|
||||
// 3. If similarity >= threshold, return cached response
|
||||
|
||||
auto end_time = std::chrono::high_resolution_clock::now();
|
||||
result.cache_lookup_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Store result in vector cache
|
||||
*/
|
||||
void LLM_Bridge::store_in_cache(const LLMRequest& req, const LLMResult& result) {
|
||||
if (!vector_db || !req.allow_cache) {
|
||||
return;
|
||||
}
|
||||
|
||||
auto start_time = std::chrono::high_resolution_clock::now();
|
||||
|
||||
// TODO: Implement cache storage
|
||||
// This would involve:
|
||||
// 1. Generate embedding for the prompt
|
||||
// 2. Store prompt embedding, response, and metadata in cache table
|
||||
|
||||
auto end_time = std::chrono::high_resolution_clock::now();
|
||||
const_cast<LLMResult&>(result).cache_store_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Select appropriate model based on request
|
||||
*/
|
||||
ModelProvider LLM_Bridge::select_model(const LLMRequest& req) {
|
||||
if (!config.provider) {
|
||||
return ModelProvider::FALLBACK_ERROR;
|
||||
}
|
||||
|
||||
if (strcmp(config.provider, "openai") == 0) {
|
||||
return ModelProvider::GENERIC_OPENAI;
|
||||
} else if (strcmp(config.provider, "anthropic") == 0) {
|
||||
return ModelProvider::GENERIC_ANTHROPIC;
|
||||
}
|
||||
|
||||
return ModelProvider::FALLBACK_ERROR;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get text embedding for vector cache
|
||||
*/
|
||||
std::vector<float> LLM_Bridge::get_text_embedding(const std::string& text) {
|
||||
std::vector<float> embedding;
|
||||
|
||||
// Use GenAI module for embedding generation
|
||||
if (GloGATH) {
|
||||
std::vector<std::string> texts = {text};
|
||||
GenAI_EmbeddingResult result = GloGATH->embed_documents(texts);
|
||||
|
||||
if (result.data && result.count > 0) {
|
||||
// Copy embedding data
|
||||
size_t dim = result.embedding_size;
|
||||
embedding.assign(result.data, result.data + dim);
|
||||
}
|
||||
}
|
||||
|
||||
return embedding;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Process a prompt using the LLM
|
||||
*/
|
||||
LLMResult LLM_Bridge::process(const LLMRequest& req) {
|
||||
LLMResult result;
|
||||
|
||||
auto total_start = std::chrono::high_resolution_clock::now();
|
||||
|
||||
// Check cache first
|
||||
result = check_cache(req);
|
||||
if (result.cached) {
|
||||
result.cache_hit = true;
|
||||
result.total_time_ms = result.cache_lookup_time_ms;
|
||||
if (GloAI) {
|
||||
GloAI->increment_llm_cache_hits();
|
||||
GloAI->add_llm_cache_lookup_time_ms(result.cache_lookup_time_ms);
|
||||
GloAI->add_llm_response_time_ms(result.total_time_ms);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
if (GloAI) {
|
||||
GloAI->increment_llm_cache_misses();
|
||||
GloAI->increment_llm_cache_lookups();
|
||||
GloAI->add_llm_cache_lookup_time_ms(result.cache_lookup_time_ms);
|
||||
}
|
||||
|
||||
// Build prompt
|
||||
std::string prompt = build_prompt(req);
|
||||
|
||||
// Select model
|
||||
ModelProvider provider = select_model(req);
|
||||
if (provider == ModelProvider::FALLBACK_ERROR) {
|
||||
result.error_code = llm_error_code_to_string(LLMErrorCode::ERR_UNKNOWN_PROVIDER);
|
||||
result.error_details = "Unknown provider: " + std::string(config.provider ? config.provider : "null");
|
||||
return result;
|
||||
}
|
||||
|
||||
// Call LLM API
|
||||
auto llm_start = std::chrono::high_resolution_clock::now();
|
||||
|
||||
std::string raw_response;
|
||||
try {
|
||||
if (provider == ModelProvider::GENERIC_OPENAI) {
|
||||
raw_response = call_generic_openai_with_retry(
|
||||
prompt,
|
||||
config.provider_model ? config.provider_model : "",
|
||||
config.provider_url ? config.provider_url : "",
|
||||
config.provider_key,
|
||||
req.request_id,
|
||||
req.max_retries,
|
||||
req.retry_backoff_ms,
|
||||
req.retry_multiplier,
|
||||
req.retry_max_backoff_ms
|
||||
);
|
||||
result.provider_used = "openai";
|
||||
} else if (provider == ModelProvider::GENERIC_ANTHROPIC) {
|
||||
raw_response = call_generic_anthropic_with_retry(
|
||||
prompt,
|
||||
config.provider_model ? config.provider_model : "",
|
||||
config.provider_url ? config.provider_url : "",
|
||||
config.provider_key,
|
||||
req.request_id,
|
||||
req.max_retries,
|
||||
req.retry_backoff_ms,
|
||||
req.retry_multiplier,
|
||||
req.retry_max_backoff_ms
|
||||
);
|
||||
result.provider_used = "anthropic";
|
||||
}
|
||||
} catch (const std::exception& e) {
|
||||
result.error_code = "ERR_EXCEPTION";
|
||||
result.error_details = e.what();
|
||||
result.http_status_code = 0;
|
||||
}
|
||||
|
||||
auto llm_end = std::chrono::high_resolution_clock::now();
|
||||
result.llm_call_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(llm_end - llm_start).count();
|
||||
|
||||
// Parse response
|
||||
if (raw_response.empty() && result.error_code.empty()) {
|
||||
result.error_code = llm_error_code_to_string(LLMErrorCode::ERR_EMPTY_RESPONSE);
|
||||
result.error_details = "LLM returned empty response";
|
||||
} else if (!result.error_code.empty()) {
|
||||
// Error already set by exception handler
|
||||
} else {
|
||||
result.text_response = raw_response;
|
||||
}
|
||||
|
||||
// Store in cache
|
||||
store_in_cache(req, result);
|
||||
|
||||
auto total_end = std::chrono::high_resolution_clock::now();
|
||||
result.total_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(total_end - total_start).count();
|
||||
|
||||
// Update status counters
|
||||
if (GloAI) {
|
||||
GloAI->add_llm_response_time_ms(result.total_time_ms);
|
||||
if (result.cache_store_time_ms > 0) {
|
||||
GloAI->add_llm_cache_store_time_ms(result.cache_store_time_ms);
|
||||
GloAI->increment_llm_cache_stores();
|
||||
}
|
||||
GloAI->increment_llm_cloud_model_calls();
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Clear the vector cache
|
||||
*/
|
||||
void LLM_Bridge::clear_cache() {
|
||||
if (!vector_db) {
|
||||
return;
|
||||
}
|
||||
|
||||
// TODO: Implement cache clearing
|
||||
// This would involve deleting all rows from llm_cache table
|
||||
|
||||
proxy_info("LLM_Bridge: Cache cleared\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get cache statistics
|
||||
*/
|
||||
std::string LLM_Bridge::get_cache_stats() {
|
||||
// TODO: Implement cache statistics
|
||||
// This would involve querying the llm_cache table for metrics
|
||||
|
||||
json stats;
|
||||
stats["entries"] = 0;
|
||||
stats["hits"] = 0;
|
||||
stats["misses"] = 0;
|
||||
|
||||
return stats.dump();
|
||||
}
|
||||
@ -1,790 +0,0 @@
|
||||
/**
|
||||
* @file NL2SQL_Converter.cpp
|
||||
* @brief Implementation of Natural Language to SQL Converter
|
||||
*
|
||||
* This file implements the NL2SQL conversion pipeline including:
|
||||
* - Vector cache operations for semantic similarity
|
||||
* - Model selection based on latency/budget
|
||||
* - Generic LLM API calls (Ollama, OpenAI-compatible, Anthropic-compatible)
|
||||
* - SQL validation and cleaning
|
||||
*
|
||||
* @see NL2SQL_Converter.h
|
||||
*/
|
||||
|
||||
#include "NL2SQL_Converter.h"
|
||||
#include "sqlite3db.h"
|
||||
#include "proxysql_utils.h"
|
||||
#include "GenAI_Thread.h"
|
||||
#include <cstring>
|
||||
#include <cstdlib>
|
||||
#include <sstream>
|
||||
#include <algorithm>
|
||||
#include <regex>
|
||||
#include <chrono>
|
||||
|
||||
using json = nlohmann::json;
|
||||
|
||||
// Global GenAI handler for embedding generation
|
||||
extern GenAI_Threads_Handler *GloGATH;
|
||||
|
||||
// Global instance is defined elsewhere if needed
|
||||
// NL2SQL_Converter *GloNL2SQL = NULL;
|
||||
|
||||
// ============================================================================
|
||||
// Error Handling Helper Functions
|
||||
// ============================================================================
|
||||
|
||||
/**
|
||||
* @brief Convert error code enum to string representation
|
||||
*
|
||||
* Returns the string representation of an error code for logging
|
||||
* and display purposes.
|
||||
*
|
||||
* @param code The error code to convert
|
||||
* @return String representation of the error code
|
||||
*/
|
||||
const char* nl2sql_error_code_to_string(NL2SQLErrorCode code) {
|
||||
switch (code) {
|
||||
case NL2SQLErrorCode::SUCCESS: return "SUCCESS";
|
||||
case NL2SQLErrorCode::ERR_API_KEY_MISSING: return "ERR_API_KEY_MISSING";
|
||||
case NL2SQLErrorCode::ERR_API_KEY_INVALID: return "ERR_API_KEY_INVALID";
|
||||
case NL2SQLErrorCode::ERR_TIMEOUT: return "ERR_TIMEOUT";
|
||||
case NL2SQLErrorCode::ERR_CONNECTION_FAILED: return "ERR_CONNECTION_FAILED";
|
||||
case NL2SQLErrorCode::ERR_RATE_LIMITED: return "ERR_RATE_LIMITED";
|
||||
case NL2SQLErrorCode::ERR_SERVER_ERROR: return "ERR_SERVER_ERROR";
|
||||
case NL2SQLErrorCode::ERR_EMPTY_RESPONSE: return "ERR_EMPTY_RESPONSE";
|
||||
case NL2SQLErrorCode::ERR_INVALID_RESPONSE: return "ERR_INVALID_RESPONSE";
|
||||
case NL2SQLErrorCode::ERR_SQL_INJECTION_DETECTED: return "ERR_SQL_INJECTION_DETECTED";
|
||||
case NL2SQLErrorCode::ERR_VALIDATION_FAILED: return "ERR_VALIDATION_FAILED";
|
||||
case NL2SQLErrorCode::ERR_UNKNOWN_PROVIDER: return "ERR_UNKNOWN_PROVIDER";
|
||||
case NL2SQLErrorCode::ERR_REQUEST_TOO_LARGE: return "ERR_REQUEST_TOO_LARGE";
|
||||
default: return "UNKNOWN_ERROR";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Format detailed error context for logging and user display
|
||||
*
|
||||
* Creates a structured error message including:
|
||||
* - Query (truncated if too long)
|
||||
* - Schema name
|
||||
* - Provider attempted
|
||||
* - Endpoint URL
|
||||
* - Specific error message
|
||||
*
|
||||
* @param req The NL2SQL request that failed
|
||||
* @param provider The provider that was attempted
|
||||
* @param url The endpoint URL that was used
|
||||
* @param error The specific error message
|
||||
* @return Formatted error context string
|
||||
*/
|
||||
static std::string format_error_context(const NL2SQLRequest& req,
|
||||
const std::string& provider,
|
||||
const std::string& url,
|
||||
const std::string& error)
|
||||
{
|
||||
std::ostringstream oss;
|
||||
oss << "NL2SQL conversion failed:\n"
|
||||
<< " Query: " << req.natural_language.substr(0, 100)
|
||||
<< (req.natural_language.length() > 100 ? "..." : "") << "\n"
|
||||
<< " Schema: " << (req.schema_name.empty() ? "(none)" : req.schema_name) << "\n"
|
||||
<< " Provider: " << provider << "\n"
|
||||
<< " URL: " << url << "\n"
|
||||
<< " Error: " << error;
|
||||
return oss.str();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set error details in NL2SQLResult
|
||||
*
|
||||
* Helper function to populate error fields in result struct.
|
||||
*
|
||||
* @param result The result to update
|
||||
* @param error_code The error code string
|
||||
* @param error_details Detailed error context
|
||||
* @param http_status HTTP status code (0 if N/A)
|
||||
* @param provider Provider that was attempted
|
||||
*/
|
||||
static void set_error_details(NL2SQLResult& result,
|
||||
const std::string& error_code,
|
||||
const std::string& error_details,
|
||||
int http_status,
|
||||
const std::string& provider)
|
||||
{
|
||||
result.error_code = error_code;
|
||||
result.error_details = error_details;
|
||||
result.http_status_code = http_status;
|
||||
result.provider_used = provider;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Constructor/Destructor
|
||||
// ============================================================================
|
||||
|
||||
/**
|
||||
* Constructor initializes with default configuration values.
|
||||
* The vector_db will be set by AI_Features_Manager during init().
|
||||
*/
|
||||
NL2SQL_Converter::NL2SQL_Converter() : vector_db(NULL) {
|
||||
config.enabled = true;
|
||||
config.query_prefix = strdup("NL2SQL:");
|
||||
config.provider = strdup("openai");
|
||||
config.provider_url = strdup("http://localhost:11434/v1/chat/completions"); // Ollama default
|
||||
config.provider_model = strdup("llama3.2");
|
||||
config.provider_key = NULL;
|
||||
config.cache_similarity_threshold = 85;
|
||||
config.timeout_ms = 30000;
|
||||
}
|
||||
|
||||
NL2SQL_Converter::~NL2SQL_Converter() {
|
||||
free(config.query_prefix);
|
||||
free(config.provider);
|
||||
free(config.provider_url);
|
||||
free(config.provider_model);
|
||||
free(config.provider_key);
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Lifecycle
|
||||
// ============================================================================
|
||||
|
||||
/**
|
||||
* Initialize the NL2SQL converter.
|
||||
* The vector DB will be provided by AI_Features_Manager during initialization.
|
||||
*/
|
||||
int NL2SQL_Converter::init() {
|
||||
proxy_info("NL2SQL: Initializing NL2SQL Converter v%s\n", NL2SQL_CONVERTER_VERSION);
|
||||
|
||||
// Vector DB will be provided by AI_Features_Manager
|
||||
// This is a stub implementation for Phase 1
|
||||
|
||||
proxy_info("NL2SQL: NL2SQL Converter initialized (stub)\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
void NL2SQL_Converter::close() {
|
||||
proxy_info("NL2SQL: NL2SQL Converter closed\n");
|
||||
}
|
||||
|
||||
void NL2SQL_Converter::update_config(const char* provider, const char* provider_url,
|
||||
const char* provider_model, const char* provider_key,
|
||||
int cache_threshold, int timeout) {
|
||||
// Free old values
|
||||
free(config.provider);
|
||||
free(config.provider_url);
|
||||
free(config.provider_model);
|
||||
free(config.provider_key);
|
||||
|
||||
// Set new values
|
||||
config.provider = strdup(provider ? provider : "openai");
|
||||
config.provider_url = strdup(provider_url ? provider_url : "http://localhost:11434/v1/chat/completions");
|
||||
config.provider_model = strdup(provider_model ? provider_model : "llama3.2");
|
||||
config.provider_key = provider_key ? strdup(provider_key) : NULL;
|
||||
config.cache_similarity_threshold = cache_threshold;
|
||||
config.timeout_ms = timeout;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Vector Cache Operations (semantic similarity cache)
|
||||
// ============================================================================
|
||||
|
||||
/**
|
||||
* @brief Generate vector embedding for text
|
||||
*
|
||||
* Generates a 1536-dimensional embedding using the GenAI module.
|
||||
* This embedding represents the semantic meaning of the text.
|
||||
*
|
||||
* @param text Input text to embed
|
||||
* @return Vector embedding (empty if not available)
|
||||
*/
|
||||
std::vector<float> NL2SQL_Converter::get_query_embedding(const std::string& text) {
|
||||
if (!GloGATH) {
|
||||
proxy_debug(PROXY_DEBUG_NL2SQL, 3, "NL2SQL: GenAI handler not available for embedding");
|
||||
return {};
|
||||
}
|
||||
|
||||
// Generate embedding using GenAI
|
||||
GenAI_EmbeddingResult emb_result = GloGATH->embed_documents({text});
|
||||
|
||||
if (!emb_result.data || emb_result.count == 0) {
|
||||
proxy_debug(PROXY_DEBUG_NL2SQL, 3, "NL2SQL: Failed to generate embedding");
|
||||
return {};
|
||||
}
|
||||
|
||||
// Convert to std::vector<float>
|
||||
std::vector<float> embedding(emb_result.data, emb_result.data + emb_result.embedding_size);
|
||||
|
||||
// Free the result data (GenAI allocates with malloc)
|
||||
if (emb_result.data) {
|
||||
free(emb_result.data);
|
||||
}
|
||||
|
||||
proxy_debug(PROXY_DEBUG_NL2SQL, 3, "NL2SQL: Generated embedding with %zu dimensions", embedding.size());
|
||||
return embedding;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Check vector cache for semantically similar previous conversions
|
||||
*
|
||||
* Uses sqlite-vec to find previous NL2SQL conversions with similar
|
||||
* natural language queries. This allows caching based on semantic meaning
|
||||
* rather than exact string matching.
|
||||
*/
|
||||
NL2SQLResult NL2SQL_Converter::check_vector_cache(const NL2SQLRequest& req) {
|
||||
NL2SQLResult result;
|
||||
result.cached = false;
|
||||
|
||||
if (!vector_db || !req.allow_cache) {
|
||||
return result;
|
||||
}
|
||||
|
||||
proxy_debug(PROXY_DEBUG_NL2SQL, 3, "NL2SQL: Checking vector cache for: %s\n",
|
||||
req.natural_language.c_str());
|
||||
|
||||
// Generate embedding for the query
|
||||
std::vector<float> query_embedding = get_query_embedding(req.natural_language);
|
||||
if (query_embedding.empty()) {
|
||||
proxy_debug(PROXY_DEBUG_NL2SQL, 3, "NL2SQL: Failed to generate embedding for cache lookup");
|
||||
return result;
|
||||
}
|
||||
|
||||
// Convert embedding to JSON for sqlite-vec MATCH
|
||||
std::string embedding_json = "[";
|
||||
for (size_t i = 0; i < query_embedding.size(); i++) {
|
||||
if (i > 0) embedding_json += ",";
|
||||
embedding_json += std::to_string(query_embedding[i]);
|
||||
}
|
||||
embedding_json += "]";
|
||||
|
||||
// Calculate distance threshold from similarity
|
||||
// Similarity 0-100 -> Distance 0-2 (cosine distance: 0=similar, 2=dissimilar)
|
||||
float distance_threshold = 2.0f - (config.cache_similarity_threshold / 50.0f);
|
||||
|
||||
// Build KNN search query
|
||||
char search[1024];
|
||||
snprintf(search, sizeof(search),
|
||||
"SELECT c.natural_language, c.generated_sql, c.schema_context, "
|
||||
" vec_distance_cosine(v.embedding, '%s') as distance "
|
||||
"FROM nl2sql_cache c "
|
||||
"JOIN nl2sql_cache_vec v ON c.id = v.rowid "
|
||||
"WHERE v.embedding MATCH '%s' "
|
||||
"AND distance < %f "
|
||||
"ORDER BY distance "
|
||||
"LIMIT 1",
|
||||
embedding_json.c_str(), embedding_json.c_str(), distance_threshold);
|
||||
|
||||
// Execute search
|
||||
sqlite3* db = vector_db->get_db();
|
||||
sqlite3_stmt* stmt = NULL;
|
||||
int rc = sqlite3_prepare_v2(db, search, -1, &stmt, NULL);
|
||||
|
||||
if (rc != SQLITE_OK) {
|
||||
proxy_debug(PROXY_DEBUG_NL2SQL, 3, "NL2SQL: Cache search prepare failed: %s", sqlite3_errmsg(db));
|
||||
return result;
|
||||
}
|
||||
|
||||
// Check if any cached queries matched
|
||||
rc = sqlite3_step(stmt);
|
||||
if (rc == SQLITE_ROW) {
|
||||
// Found similar cached query
|
||||
result.cached = true;
|
||||
|
||||
// Extract cached result (natural_lang and schema_ctx available but not currently used)
|
||||
// const char* natural_lang = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 0));
|
||||
const char* generated_sql = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 1));
|
||||
// const char* schema_ctx = reinterpret_cast<const char*>(sqlite3_column_text(stmt, 2));
|
||||
double distance = sqlite3_column_double(stmt, 3);
|
||||
|
||||
// Calculate similarity score from distance
|
||||
float similarity = 1.0f - (distance / 2.0f);
|
||||
result.confidence = similarity;
|
||||
result.sql_query = generated_sql ? generated_sql : "";
|
||||
result.explanation = "Retrieved from semantic cache (similarity: " +
|
||||
std::to_string((int)(similarity * 100)) + "%)";
|
||||
|
||||
proxy_info("NL2SQL: Cache hit! (distance: %.3f, similarity: %.0f%%)\n",
|
||||
distance, similarity * 100);
|
||||
}
|
||||
|
||||
sqlite3_finalize(stmt);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Store a new NL2SQL conversion in the vector cache
|
||||
*
|
||||
* Stores both the original query and generated SQL, along with
|
||||
* the query embedding for semantic similarity search.
|
||||
*/
|
||||
void NL2SQL_Converter::store_in_vector_cache(const NL2SQLRequest& req, const NL2SQLResult& result) {
|
||||
if (!vector_db || !req.allow_cache) {
|
||||
return;
|
||||
}
|
||||
|
||||
proxy_debug(PROXY_DEBUG_NL2SQL, 3, "NL2SQL: Storing in vector cache: %s -> %s\n",
|
||||
req.natural_language.c_str(), result.sql_query.c_str());
|
||||
|
||||
// Generate embedding for the natural language query
|
||||
std::vector<float> embedding = get_query_embedding(req.natural_language);
|
||||
if (embedding.empty()) {
|
||||
proxy_debug(PROXY_DEBUG_NL2SQL, 3, "NL2SQL: Failed to generate embedding for cache storage");
|
||||
return;
|
||||
}
|
||||
|
||||
// Insert into main table with embedding BLOB
|
||||
sqlite3* db = vector_db->get_db();
|
||||
sqlite3_stmt* stmt = NULL;
|
||||
const char* insert = "INSERT INTO nl2sql_cache "
|
||||
"(natural_language, generated_sql, schema_context, embedding) "
|
||||
"VALUES (?, ?, ?, ?)";
|
||||
|
||||
int rc = sqlite3_prepare_v2(db, insert, -1, &stmt, NULL);
|
||||
if (rc != SQLITE_OK) {
|
||||
proxy_error("NL2SQL: Failed to prepare cache insert: %s\n", sqlite3_errmsg(db));
|
||||
return;
|
||||
}
|
||||
|
||||
// Bind values
|
||||
sqlite3_bind_text(stmt, 1, req.natural_language.c_str(), -1, SQLITE_TRANSIENT);
|
||||
sqlite3_bind_text(stmt, 2, result.sql_query.c_str(), -1, SQLITE_TRANSIENT);
|
||||
|
||||
// Schema context (may be empty)
|
||||
std::string schema_context;
|
||||
if (!req.context_tables.empty()) {
|
||||
schema_context = "{"; // Simple format: table names
|
||||
for (size_t i = 0; i < req.context_tables.size(); i++) {
|
||||
if (i > 0) schema_context += ",";
|
||||
schema_context += req.context_tables[i];
|
||||
}
|
||||
schema_context += "}";
|
||||
}
|
||||
sqlite3_bind_text(stmt, 3, schema_context.c_str(), -1, SQLITE_TRANSIENT);
|
||||
|
||||
// Bind embedding as BLOB
|
||||
sqlite3_bind_blob(stmt, 4, embedding.data(), embedding.size() * sizeof(float), SQLITE_TRANSIENT);
|
||||
|
||||
// Execute insert
|
||||
rc = sqlite3_step(stmt);
|
||||
if (rc != SQLITE_DONE) {
|
||||
proxy_error("NL2SQL: Failed to insert into cache: %s\n", sqlite3_errmsg(db));
|
||||
sqlite3_finalize(stmt);
|
||||
return;
|
||||
}
|
||||
|
||||
sqlite3_finalize(stmt);
|
||||
|
||||
// Get the inserted rowid
|
||||
sqlite3_int64 rowid = sqlite3_last_insert_rowid(db);
|
||||
|
||||
// Update virtual table (sqlite-vec needs explicit rowid insertion)
|
||||
char update_vec[256];
|
||||
snprintf(update_vec, sizeof(update_vec),
|
||||
"INSERT INTO nl2sql_cache_vec(rowid) VALUES (%lld)", rowid);
|
||||
|
||||
char* err = NULL;
|
||||
rc = sqlite3_exec(db, update_vec, NULL, NULL, &err);
|
||||
if (rc != SQLITE_OK) {
|
||||
proxy_error("NL2SQL: Failed to update vec table: %s\n", err ? err : "unknown");
|
||||
if (err) sqlite3_free(err);
|
||||
return;
|
||||
}
|
||||
|
||||
proxy_info("NL2SQL: Stored in cache (id: %lld)\n", rowid);
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Model Selection Logic
|
||||
// ============================================================================
|
||||
|
||||
/**
|
||||
* @brief Select the best model provider for the given request
|
||||
*
|
||||
* Selection criteria:
|
||||
* 1. Explicit provider preference -> use that
|
||||
* 2. For generic providers: check API key availability (only for cloud)
|
||||
*
|
||||
* @note For local endpoints (like Ollama), API key is optional
|
||||
*/
|
||||
ModelProvider NL2SQL_Converter::select_model(const NL2SQLRequest& req) {
|
||||
// Check provider preference
|
||||
std::string provider(config.provider ? config.provider : "openai");
|
||||
|
||||
if (provider == "openai") {
|
||||
// For local endpoints, API key is optional
|
||||
// Check if this is a local endpoint
|
||||
std::string url(config.provider_url ? config.provider_url : "");
|
||||
bool is_local = (url.find("localhost") != std::string::npos ||
|
||||
url.find("127.0.0.1") != std::string::npos ||
|
||||
url.find("http://localhost:11434") != std::string::npos);
|
||||
|
||||
if (!is_local && !config.provider_key) {
|
||||
proxy_error("NL2SQL: OpenAI-compatible provider requested but API key not configured\n");
|
||||
return ModelProvider::FALLBACK_ERROR;
|
||||
}
|
||||
return ModelProvider::GENERIC_OPENAI;
|
||||
} else if (provider == "anthropic") {
|
||||
// Anthropic always requires API key
|
||||
if (!config.provider_key) {
|
||||
proxy_error("NL2SQL: Anthropic-compatible provider requested but API key not configured\n");
|
||||
return ModelProvider::FALLBACK_ERROR;
|
||||
}
|
||||
return ModelProvider::GENERIC_ANTHROPIC;
|
||||
}
|
||||
|
||||
// Unknown provider, default to OpenAI format
|
||||
proxy_warning("NL2SQL: Unknown provider '%s', defaulting to OpenAI format\n", provider.c_str());
|
||||
return ModelProvider::GENERIC_OPENAI;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Prompt Building
|
||||
// ============================================================================
|
||||
|
||||
/**
|
||||
* @brief Build the prompt for LLM with schema context
|
||||
*
|
||||
* Constructs a comprehensive prompt including:
|
||||
* - System instructions
|
||||
* - Schema information (tables, columns)
|
||||
* - User's natural language query
|
||||
*/
|
||||
std::string NL2SQL_Converter::build_prompt(const NL2SQLRequest& req, const std::string& schema_context) {
|
||||
std::ostringstream prompt;
|
||||
|
||||
// System instructions
|
||||
prompt << "You are a SQL expert. Convert the following natural language question to a SQL query.\n\n";
|
||||
|
||||
// Add schema context if available
|
||||
if (!schema_context.empty()) {
|
||||
prompt << "Database Schema:\n";
|
||||
prompt << schema_context;
|
||||
prompt << "\n";
|
||||
}
|
||||
|
||||
// User's question
|
||||
prompt << "Question: " << req.natural_language << "\n\n";
|
||||
prompt << "Return ONLY the SQL query. No explanations, no markdown formatting.\n";
|
||||
|
||||
return prompt.str();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get schema context for the specified tables
|
||||
*
|
||||
* Retrieves table and column information from the MySQL_Tool_Handler
|
||||
* or from cached schema information.
|
||||
*/
|
||||
std::string NL2SQL_Converter::get_schema_context(const std::vector<std::string>& tables) {
|
||||
// TODO: Implement schema context retrieval via MySQL_Tool_Handler
|
||||
// For Phase 2, return empty string
|
||||
return "";
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// SQL Validation
|
||||
// ============================================================================
|
||||
|
||||
/**
|
||||
* @brief Validate SQL and generate confidence score
|
||||
*
|
||||
* Performs multi-factor validation:
|
||||
* 1. SQL keyword detection
|
||||
* 2. Structural validation (parentheses, quotes)
|
||||
* 3. Common SQL injection pattern detection
|
||||
* 4. Length and complexity checks
|
||||
*
|
||||
* @param sql The SQL to validate
|
||||
* @return Confidence score 0.0-1.0
|
||||
*/
|
||||
float NL2SQL_Converter::validate_and_score_sql(const std::string& sql) {
|
||||
if (sql.empty()) {
|
||||
return 0.0f;
|
||||
}
|
||||
|
||||
float confidence = 0.0f;
|
||||
int checks_passed = 0;
|
||||
int total_checks = 0;
|
||||
|
||||
// Trim leading whitespace for validation
|
||||
size_t start = sql.find_first_not_of(" \t\n\r");
|
||||
if (start == std::string::npos) {
|
||||
return 0.0f; // Empty or whitespace only
|
||||
}
|
||||
std::string trimmed_sql = sql.substr(start);
|
||||
std::string upper_sql = trimmed_sql;
|
||||
std::transform(upper_sql.begin(), upper_sql.end(), upper_sql.begin(), ::toupper);
|
||||
|
||||
// Check 1: SQL keyword detection
|
||||
total_checks++;
|
||||
static const std::vector<std::string> sql_keywords = {
|
||||
"SELECT", "INSERT", "UPDATE", "DELETE", "CREATE", "ALTER", "DROP",
|
||||
"TRUNCATE", "REPLACE", "GRANT", "REVOKE", "SHOW", "DESCRIBE",
|
||||
"EXPLAIN", "WITH", "CALL", "BEGIN", "COMMIT", "ROLLBACK"
|
||||
};
|
||||
for (const auto& keyword : sql_keywords) {
|
||||
if (upper_sql.find(keyword) == 0 || upper_sql.find("-- " + keyword) == 0) {
|
||||
confidence += 0.4f;
|
||||
checks_passed++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Check 2: Structural validation - balanced parentheses
|
||||
total_checks++;
|
||||
int paren_count = 0;
|
||||
bool balanced_parens = true;
|
||||
for (char c : sql) {
|
||||
if (c == '(') paren_count++;
|
||||
else if (c == ')') paren_count--;
|
||||
if (paren_count < 0) {
|
||||
balanced_parens = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (balanced_parens && paren_count == 0) {
|
||||
confidence += 0.15f;
|
||||
checks_passed++;
|
||||
} else if (paren_count != 0) {
|
||||
// Unbalanced parentheses reduce confidence
|
||||
confidence -= 0.1f;
|
||||
}
|
||||
|
||||
// Check 3: Balanced quotes
|
||||
total_checks++;
|
||||
int single_quotes = 0;
|
||||
int double_quotes = 0;
|
||||
for (size_t i = 0; i < sql.length(); i++) {
|
||||
if (sql[i] == '\'' && (i == 0 || sql[i-1] != '\\')) {
|
||||
single_quotes++;
|
||||
}
|
||||
if (sql[i] == '"' && (i == 0 || sql[i-1] != '\\')) {
|
||||
double_quotes++;
|
||||
}
|
||||
}
|
||||
if (single_quotes % 2 == 0 && double_quotes % 2 == 0) {
|
||||
confidence += 0.15f;
|
||||
checks_passed++;
|
||||
} else {
|
||||
confidence -= 0.1f;
|
||||
}
|
||||
|
||||
// Check 4: Minimum length check
|
||||
total_checks++;
|
||||
if (sql.length() >= 10) {
|
||||
confidence += 0.1f;
|
||||
checks_passed++;
|
||||
}
|
||||
|
||||
// Check 5: Contains FROM clause for SELECT statements (quality indicator)
|
||||
total_checks++;
|
||||
if (upper_sql.find("SELECT") == 0 && upper_sql.find("FROM") != std::string::npos) {
|
||||
confidence += 0.1f;
|
||||
checks_passed++;
|
||||
}
|
||||
|
||||
// Check 6: SQL injection pattern detection (negative impact)
|
||||
total_checks++;
|
||||
static const std::vector<std::string> injection_patterns = {
|
||||
"; DROP", "; DELETE", "; INSERT", "; UPDATE",
|
||||
"1=1", "1 = 1", "OR TRUE", "AND TRUE",
|
||||
"UNION SELECT", "'; --", "\"; --"
|
||||
};
|
||||
bool has_injection = false;
|
||||
std::string check_upper = upper_sql;
|
||||
for (const auto& pattern : injection_patterns) {
|
||||
std::string pattern_upper = pattern;
|
||||
std::transform(pattern_upper.begin(), pattern_upper.end(), pattern_upper.begin(), ::toupper);
|
||||
if (check_upper.find(pattern_upper) != std::string::npos) {
|
||||
has_injection = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!has_injection) {
|
||||
confidence += 0.1f;
|
||||
checks_passed++;
|
||||
} else {
|
||||
confidence -= 0.3f; // Significant penalty for injection patterns
|
||||
proxy_warning("NL2SQL: Potential SQL injection pattern detected in generated SQL\n");
|
||||
}
|
||||
|
||||
// Normalize confidence to 0.0-1.0 range
|
||||
if (confidence < 0.0f) confidence = 0.0f;
|
||||
if (confidence > 1.0f) confidence = 1.0f;
|
||||
|
||||
// Additional logging for low confidence
|
||||
if (confidence < 0.5f) {
|
||||
proxy_debug(PROXY_DEBUG_NL2SQL, 2,
|
||||
"NL2SQL: Low confidence score %.2f (passed %d/%d checks). SQL: %s\n",
|
||||
confidence, checks_passed, total_checks, sql.c_str());
|
||||
}
|
||||
|
||||
return confidence;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Main Conversion Method
|
||||
// ============================================================================
|
||||
|
||||
/**
|
||||
* @brief Convert natural language to SQL (main entry point)
|
||||
*
|
||||
* Conversion Pipeline:
|
||||
* 1. Check vector cache for semantically similar queries
|
||||
* 2. Build prompt with schema context
|
||||
* 3. Select appropriate model (Ollama or generic provider)
|
||||
* 4. Call LLM API via HTTP
|
||||
* 5. Parse and clean SQL response
|
||||
* 6. Store in vector cache for future use
|
||||
*
|
||||
* The confidence score is calculated based on:
|
||||
* - SQL keyword validation (does it look like SQL?)
|
||||
* - Response quality (non-empty, well-formed)
|
||||
* - Default score of 0.85 for valid-looking SQL
|
||||
*
|
||||
* @note This is a synchronous blocking call.
|
||||
*/
|
||||
NL2SQLResult NL2SQL_Converter::convert(const NL2SQLRequest& req) {
|
||||
NL2SQLResult result;
|
||||
|
||||
// Start timing the entire conversion
|
||||
auto start_time = std::chrono::steady_clock::now();
|
||||
|
||||
proxy_info("NL2SQL: Converting query: %s\n", req.natural_language.c_str());
|
||||
|
||||
// Check vector cache first
|
||||
auto cache_start = std::chrono::steady_clock::now();
|
||||
if (req.allow_cache) {
|
||||
result = check_vector_cache(req);
|
||||
if (result.cached && !result.sql_query.empty()) {
|
||||
proxy_info("NL2SQL: Cache hit! Returning cached SQL\n");
|
||||
// Set timing information for cache hit
|
||||
auto cache_end = std::chrono::steady_clock::now();
|
||||
int cache_lookup_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(cache_end - cache_start).count();
|
||||
result.total_time_ms = cache_lookup_time_ms;
|
||||
result.cache_lookup_time_ms = cache_lookup_time_ms;
|
||||
result.cache_hit = true;
|
||||
return result;
|
||||
}
|
||||
}
|
||||
auto cache_end = std::chrono::steady_clock::now();
|
||||
int cache_lookup_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(cache_end - cache_start).count();
|
||||
|
||||
// Build prompt with schema context
|
||||
std::string schema_context = get_schema_context(req.context_tables);
|
||||
std::string prompt = build_prompt(req, schema_context);
|
||||
|
||||
// Select model provider
|
||||
ModelProvider provider = select_model(req);
|
||||
|
||||
// Call appropriate LLM
|
||||
std::string raw_sql;
|
||||
std::string url;
|
||||
const char* model = NULL;
|
||||
const char* key = config.provider_key;
|
||||
|
||||
// Time the LLM call
|
||||
auto llm_start = std::chrono::steady_clock::now();
|
||||
switch (provider) {
|
||||
case ModelProvider::GENERIC_OPENAI:
|
||||
// Use configured URL or default Ollama endpoint
|
||||
url = (config.provider_url && strlen(config.provider_url) > 0)
|
||||
? config.provider_url
|
||||
: "http://localhost:11434/v1/chat/completions";
|
||||
model = config.provider_model ? config.provider_model : "llama3.2";
|
||||
raw_sql = call_generic_openai_with_retry(prompt, model, url, key, req.request_id,
|
||||
req.max_retries, req.retry_backoff_ms,
|
||||
req.retry_multiplier, req.retry_max_backoff_ms);
|
||||
result.explanation = "Generated by OpenAI-compatible provider (" + std::string(model) + ")";
|
||||
result.provider_used = "openai";
|
||||
break;
|
||||
case ModelProvider::GENERIC_ANTHROPIC:
|
||||
// Use configured URL or default Anthropic endpoint
|
||||
url = (config.provider_url && strlen(config.provider_url) > 0)
|
||||
? config.provider_url
|
||||
: "https://api.anthropic.com/v1/messages";
|
||||
model = config.provider_model ? config.provider_model : "claude-3-haiku";
|
||||
raw_sql = call_generic_anthropic_with_retry(prompt, model, url, key, req.request_id,
|
||||
req.max_retries, req.retry_backoff_ms,
|
||||
req.retry_multiplier, req.retry_max_backoff_ms);
|
||||
result.explanation = "Generated by Anthropic-compatible provider (" + std::string(model) + ")";
|
||||
result.provider_used = "anthropic";
|
||||
break;
|
||||
case ModelProvider::FALLBACK_ERROR:
|
||||
default: {
|
||||
// Format error context
|
||||
std::string provider_str(config.provider ? config.provider : "unknown");
|
||||
std::string url_str(config.provider_url ? config.provider_url : "not configured");
|
||||
std::string error_msg = "API key not configured or provider error";
|
||||
std::string context = format_error_context(req, provider_str, url_str, error_msg);
|
||||
|
||||
proxy_error("NL2SQL: %s\n", context.c_str());
|
||||
|
||||
set_error_details(result, "ERR_API_KEY_MISSING", context, 0, provider_str);
|
||||
result.sql_query = "-- NL2SQL conversion failed: " + error_msg + "\n";
|
||||
result.confidence = 0.0f;
|
||||
result.explanation = "Error: " + error_msg;
|
||||
return result;
|
||||
}
|
||||
}
|
||||
auto llm_end = std::chrono::steady_clock::now();
|
||||
int llm_call_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(llm_end - llm_start).count();
|
||||
|
||||
// Validate and clean SQL
|
||||
if (raw_sql.empty()) {
|
||||
std::string provider_str(config.provider ? config.provider : "unknown");
|
||||
std::string url_str(config.provider_url ? config.provider_url : "not configured");
|
||||
std::string error_msg = "empty response from LLM";
|
||||
std::string context = format_error_context(req, provider_str, url_str, error_msg);
|
||||
|
||||
proxy_error("NL2SQL: %s\n", context.c_str());
|
||||
|
||||
set_error_details(result, "ERR_EMPTY_RESPONSE", context, 0, provider_str);
|
||||
result.sql_query = "-- NL2SQL conversion failed: " + error_msg + "\n";
|
||||
result.confidence = 0.0f;
|
||||
result.explanation += " (empty response)";
|
||||
return result;
|
||||
}
|
||||
|
||||
// Improved SQL validation
|
||||
float confidence = validate_and_score_sql(raw_sql);
|
||||
result.sql_query = raw_sql;
|
||||
result.confidence = confidence;
|
||||
|
||||
// Store in vector cache for future use if confidence is good enough
|
||||
auto cache_store_start = std::chrono::steady_clock::now();
|
||||
if (req.allow_cache && confidence >= 0.5f) {
|
||||
store_in_vector_cache(req, result);
|
||||
}
|
||||
auto cache_store_end = std::chrono::steady_clock::now();
|
||||
int cache_store_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(cache_store_end - cache_store_start).count();
|
||||
|
||||
proxy_info("NL2SQL: Conversion complete. Confidence: %.2f\n", result.confidence);
|
||||
|
||||
// Calculate total time
|
||||
auto end_time = std::chrono::steady_clock::now();
|
||||
int total_time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();
|
||||
|
||||
// Populate timing information in result
|
||||
result.total_time_ms = total_time_ms;
|
||||
result.cache_lookup_time_ms = cache_lookup_time_ms;
|
||||
result.cache_store_time_ms = cache_store_time_ms;
|
||||
result.llm_call_time_ms = llm_call_time_ms;
|
||||
result.cache_hit = false; // This will be set to true if we return from cache hit
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Cache Management
|
||||
// ============================================================================
|
||||
|
||||
void NL2SQL_Converter::clear_cache() {
|
||||
proxy_info("NL2SQL: Cache cleared\n");
|
||||
// TODO: Implement cache clearing
|
||||
}
|
||||
|
||||
std::string NL2SQL_Converter::get_cache_stats() {
|
||||
return "{\"entries\": 0, \"hits\": 0, \"misses\": 0}";
|
||||
// TODO: Implement real cache statistics
|
||||
}
|
||||
Loading…
Reference in new issue