improve service names (#54)

- embedding-server => model_server
- public-types => public_types
- chatbot-ui => chatbot_ui
- function-calling => function_calling

public_types/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "public_types"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+open-message-format-embeddings = { path = "../open-message-format/clients/omf-embeddings-rust" }

public_types/src/common_types.rs

@@ -0,0 +1,124 @@
+use crate::configuration::PromptTarget;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct EmbeddingRequest {
+    pub prompt_target: PromptTarget,
+}
+
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+pub enum EmbeddingType {
+    Name,
+    Description,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct VectorPoint {
+    pub id: String,
+    pub payload: HashMap<String, String>,
+    pub vector: Vec<f64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct StoreVectorEmbeddingsRequest {
+    pub points: Vec<VectorPoint>,
+}
+
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SearchPointResult {
+    pub id: String,
+    pub version: i32,
+    pub score: f64,
+    pub payload: HashMap<String, String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolParameter {
+    #[serde(rename = "type")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub parameter_type: Option<String>,
+    pub description: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub required: Option<bool>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolParameters {
+    #[serde(rename = "type")]
+    pub parameters_type: String,
+    pub properties: HashMap<String, ToolParameter>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolsDefinition {
+    pub name: String,
+    pub description: String,
+    pub parameters: ToolParameters,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BoltFCResponse {
+    pub model: String,
+    pub message: open_ai::Message,
+    pub done_reason: String,
+    pub done: bool,
+    pub resolver_name: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum IntOrString {
+    Integer(i32),
+    Text(String),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolCallDetail {
+    pub name: String,
+    pub arguments: HashMap<String, IntOrString>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct BoltFCToolsCall {
+    pub tool_calls: Vec<ToolCallDetail>,
+}
+
+pub mod open_ai {
+    use serde::{Deserialize, Serialize};
+
+    use super::ToolsDefinition;
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub struct ChatCompletions {
+        #[serde(default)]
+        pub model: String,
+        pub messages: Vec<Message>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub tools: Option<Vec<ToolsDefinition>>,
+    }
+
+    #[derive(Debug, Clone, Serialize, Deserialize)]
+    pub struct Message {
+        pub role: String,
+        pub content: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub model: Option<String>,
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ZeroShotClassificationRequest {
+    pub input: String,
+    pub labels: Vec<String>,
+    pub model: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ZeroShotClassificationResponse {
+    pub predicted_class: String,
+    pub predicted_class_score: f64,
+    pub scores: HashMap<String, f64>,
+    pub model: String,
+}

public_types/src/configuration.rs

@@ -0,0 +1,167 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Configuration {
+    pub default_prompt_endpoint: String,
+    pub load_balancing: LoadBalancing,
+    pub timeout_ms: u64,
+    pub embedding_provider: EmbeddingProviver,
+    pub llm_providers: Vec<LlmProvider>,
+    pub system_prompt: Option<String>,
+    pub prompt_targets: Vec<PromptTarget>,
+    pub ratelimits: Option<Vec<Ratelimit>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Ratelimit {
+    pub provider: String,
+    pub selector: Header,
+    pub limit: Limit,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Limit {
+    pub tokens: u32,
+    pub unit: TimeUnit,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum TimeUnit {
+    #[serde(rename = "second")]
+    Second,
+    #[serde(rename = "minute")]
+    Minute,
+    #[serde(rename = "hour")]
+    Hour,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
+pub struct Header {
+    pub key: String,
+    pub value: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum LoadBalancing {
+    #[serde(rename = "round_robin")]
+    RoundRobin,
+    #[serde(rename = "random")]
+    Random,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+//TODO: use enum for model, but if there is a new model, we need to update the code
+pub struct EmbeddingProviver {
+    pub name: String,
+    pub model: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+//TODO: use enum for model, but if there is a new model, we need to update the code
+pub struct LlmProvider {
+    pub name: String,
+    pub api_key: Option<String>,
+    pub model: String,
+    pub default: Option<bool>,
+    pub endpoint: Option<EnpointType>,
+}
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum EnpointType {
+    String(String),
+    Struct(Endpoint),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Endpoint {
+    pub cluster: String,
+    pub path: Option<String>,
+    pub method: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Parameter {
+    pub name: String,
+    #[serde(rename = "type")]
+    pub parameter_type: Option<String>,
+    pub description: String,
+    pub required: Option<bool>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub enum PromptType {
+    #[serde(rename = "function_resolver")]
+    FunctionResolver,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PromptTarget {
+    #[serde(rename = "type")]
+    pub prompt_type: PromptType,
+    pub name: String,
+    pub description: String,
+    pub parameters: Option<Vec<Parameter>>,
+    pub endpoint: Option<Endpoint>,
+    pub system_prompt: Option<String>,
+}
+
+#[cfg(test)]
+mod test {
+    pub const CONFIGURATION: &str = r#"
+default_prompt_endpoint: "127.0.0.1"
+load_balancing: "round_robin"
+timeout_ms: 5000
+
+embedding_provider:
+  name: "SentenceTransformer"
+  model: "all-MiniLM-L6-v2"
+
+llm_providers:
+  - name: "open-ai-gpt-4"
+    api_key: "$OPEN_AI_API_KEY"
+    model: gpt-4
+
+system_prompt: |
+  You are a helpful weather forecaster. Please following following guidelines when responding to user queries:
+  - Use farenheight for temperature
+  - Use miles per hour for wind speed
+
+prompt_targets:
+
+  - type: function_resolver
+    name: weather_forecast
+    few_shot_examples:
+      - what is the weather in New York?
+    endpoint:
+      cluster: weatherhost
+      path: /weather
+    parameters:
+      - name: location
+        required: true
+        description: "The location for which the weather is requested"
+
+  - type: function_resolver
+    name: weather_forecast_2
+    few_shot_examples:
+      - what is the weather in New York?
+    endpoint:
+      cluster: weatherhost
+      path: /weather
+    parameters:
+      - name: city
+        description: "The location for which the weather is requested"
+
+ratelimits:
+  - provider: open-ai-gpt-4
+    selector:
+      key: x-katanemo-openai-limit-id
+    limit:
+      tokens: 100
+      unit: minute
+  "#;
+
+    #[test]
+    fn test_deserialize_configuration() {
+        let _: super::Configuration = serde_yaml::from_str(CONFIGURATION).unwrap();
+    }
+}

public_types/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod common_types;
+pub mod configuration;