TOOL-519: Mock LLM client prototype

Author: the-nick-fischer

application/apps/indexer/mcp/src/client/llm.rs

@@ -0,0 +1,46 @@
+/// Mock
+use rmcp::serde_json;
+use std::time::Duration;
+use tokio::time::sleep;
+
+use super::{LlmClient, LlmRequest, LlmResponse, McpError};
+
+pub struct MockLlmClient;
+
+impl LlmClient for MockLlmClient {
+    async fn complete(&self, messages: Vec<LlmRequest>) -> Result<LlmResponse, McpError> {
+        match messages.last() {
+            Some(LlmRequest::UserPrompt { content }) => {
+                // Wait 5 seconds to simulate the LLm processing
+                sleep(Duration::from_secs(5)).await;
+                // TODO: Try using content as filter value insead
+                let filter_value = "icmp_seq=13";
+                let tool_call = LlmResponse::ToolCall {
+                    tool_name: "apply_filter".into(),
+                    arguments: serde_json::json!({
+                        "filters": [
+                            {
+                                "value": filter_value,
+                                "is_regex": false,
+                                "ignore_case": true,
+                                "is_word": true
+                            }
+                        ]
+                    }),
+                };
+                Ok(tool_call)
+            }
+            Some(LlmRequest::ToolResult { content }) => {
+                // Wait 3 seconds to simulate the LLm processing
+                sleep(Duration::from_secs(3)).await;
+                let final_response = LlmResponse::FinalResponse {
+                    content: format!("Final LLM Answer: Tool result {}", content),
+                };
+                Ok(final_response)
+            }
+            _ => Err(McpError::Generic {
+                message: "Mock  LLM Client received unsupported request".into(),
+            }),
+        }
+    }
+}

application/apps/indexer/mcp/src/client/llm/mock.rs

@@ -0,0 +1,41 @@
+use rmcp::serde_json::Value;
+
+use crate::types::McpError;
+
+pub mod mock;
+
+// Client requests to the LLM
+pub enum LlmRequest {
+    SystemPrompt { content: String },
+    UserPrompt { content: String },
+    ToolResult { content: String },
+}
+
+// LLM responses to the client
+pub enum LlmResponse {
+    FinalResponse { content: String },
+    ToolCall { tool_name: String, arguments: Value },
+}
+
+pub trait LlmClient: Send + Sync {
+    async fn complete(&self, messages: Vec<LlmRequest>) -> Result<LlmResponse, McpError>;
+}
+
+pub enum LlmConfig {
+    Mock,
+    // TODO: Add other LlmConfig variants here. E.g.:
+    // OpenAi { api_key: String, model: String },
+}
+
+pub enum LlmBackend {
+    Mock(mock::MockLlmClient),
+    // OpenAi(openai::OpenAiClient),
+}
+
+impl LlmClient for LlmBackend {
+    async fn complete(&self, messages: Vec<LlmRequest>) -> Result<LlmResponse, McpError> {
+        match self {
+            LlmBackend::Mock(client) => client.complete(messages).await,
+        }
+    }
+}

application/apps/indexer/mcp/src/client/llm/mod.rs

@@ -4,7 +4,7 @@ use tokio::{select, sync::mpsc};
 
 use rmcp::{
     RoleClient,
-    model::{ClientInfo, Implementation, InitializeRequestParam},
+    model::{CallToolRequestParam, ClientInfo, Implementation, InitializeRequestParam},
     service::{RunningService, ServiceExt},
     transport::StreamableHttpClientTransport,
 };
@@ -71,7 +71,7 @@ impl MCPClient {
             },
         };
 
-        let mcp_service = client_info
+        let mcp_service: RunningService<RoleClient, InitializeRequestParam> = client_info
             .serve(transport)
             .await
             .map_err(|e| McpError::Generic {
@@ -83,6 +83,7 @@ impl MCPClient {
         let chipmunk_to_client_rx = self.chipmunk_to_client_rx;
 
         let tools = mcp_service.list_tools(Default::default()).await?;
+        warn!("Available tools: {:?}", tools);
 
         let chipmunk_response_tx = self.client_to_chipmunk_tx.clone();
 

application/apps/indexer/mcp/src/client/mod.rs

@@ -20,12 +20,9 @@ pub struct McpChannelEndpoints {
 }
 
 pub fn new() -> (McpServer, MCPClient, McpChannelEndpoints) {
-    let llm_config = LlmConfig::Dummy {
-        api_key: String::default(),
-        model: None,
-    };
+    let llm_config = LlmConfig::Mock {};
     let mcp_config = McpConfig {
-        url: String::from("http//:localhost:8080/chipmunk_mcp"),
+        url: String::from("http//:localhost:8181"),
     };
     let (mcp_client, chipmunk_to_client_tx, client_to_chipmunk_rx) =
         MCPClient::new(mcp_config, llm_config);