Native: Complete MCP workflow for search filter

Author: sudeeptarlekar

application/apps/indexer/gui/application/src/host/message.rs

@@ -29,6 +29,11 @@ pub enum HostMessage {
         /// instead of creating a new tab for the session.
         session_setup_id: Option<Uuid>,
     },
+    SessionFilterUpdated {
+        session_id: Uuid,
+        operation_id: Uuid,
+        filters: Vec<processor::search::filter::SearchFilter>,
+    },
     /// Open Session Setup for concatenating files.
     MultiFilesSetup(Box<MultiFileState>),
 }

application/apps/indexer/gui/application/src/host/service/mod.rs

@@ -10,7 +10,7 @@ use itertools::Itertools;
 use tokio::runtime::Handle;
 use uuid::Uuid;
 
-use mcp::server::{McpServer, tasks::Tasks};
+use mcp::server::McpServer;
 use parsers::dlt::DltFilterConfig;
 use stypes::{
     DltParserSettings, FileFormat, ObserveOptions, ObserveOrigin, ParserType, SomeIpParserSettings,
@@ -91,7 +91,6 @@ impl HostService {
     async fn handle_command(&mut self, cmd: HostCommand) -> Result<(), HostError> {
         match cmd {
             HostCommand::OpenFiles(files) => {
-                println!("🔵 HostCommand::OpenFiles");
                 log::trace!("Got open files request. Files: {files:?}");
 
                 if files.len() == 1 {
@@ -102,7 +101,6 @@ impl HostService {
                 }
             }
             HostCommand::OpenAsSessions(files) => {
-                println!("🔵 HostCommand::OpenAsSessions");
                 for file in files {
                     if let Err(err) = self.open_single_file(file).await {
                         self.send_host_err(err).await;
@@ -112,10 +110,7 @@ impl HostService {
             HostCommand::OpenFromDirectory {
                 dir_path,
                 target_format,
-            } => {
-                println!("🔵 HostCommand::OpenFromDirectory");
-                self.files_in_dir(dir_path, target_format).await?
-            }
+            } => self.files_in_dir(dir_path, target_format).await?,
 
             HostCommand::ConcatFiles(files) => self.concatenate_files(files).await?,
             HostCommand::ConnectionSessionSetup { stream, parser } => {

application/apps/indexer/gui/application/src/host/ui/mod.rs

@@ -156,6 +156,15 @@ impl Host {
                 session_setup_id,
                 self.senders.cmd_tx.clone(),
             ),
+            HostMessage::SessionFilterUpdated {
+                session_id,
+                operation_id,
+                filters,
+            } => {
+                self.state.sessions.get_mut(&session_id).map(|session| {
+                    session.update_session_filters(operation_id, filters);
+                });
+            }
             HostMessage::MultiFilesSetup(state) => self
                 .state
                 .add_multi_files(*state, self.senders.cmd_tx.clone()),

application/apps/indexer/gui/application/src/host/ui/state.rs

@@ -9,7 +9,6 @@ use crate::{
         ui::{
             multi_setup::{MultiFileSetup, state::MultiFileState},
             session_setup::{SessionSetup, state::SessionSetupState},
-            settings::ai_config::AiConfiguration,
             tabs::TabType,
         },
     },

application/apps/indexer/gui/application/src/session/service/mod.rs

@@ -96,7 +96,7 @@ impl SessionService {
     async fn run(mut self) {
         log::trace!("Start Session Service {}", self.session_id());
 
-        let (client, prompt_tx, mut response_rx) = McpClient::new();
+        let (client, prompt_tx, mut _response_rx) = McpClient::new();
         if let Err(err) = client.start().await {
             log::error!(
                 "Failed to start MCP client for session {}: {err:?}",
@@ -120,20 +120,21 @@ impl SessionService {
                     match task {
                         Tasks::ApplySearchFilter { session_id, filters, task_result_tx } => {
                             if self.session_id() == session_id {
-                                let cmd = SessionCommand::ApplySearchFilter { operation_id: session_id, filters: filters.clone() };
+                                let operation_id = Uuid::new_v4();
+                                let cmd = SessionCommand::ApplySearchFilter { operation_id: operation_id.clone(), filters: filters.clone() };
+
                                 match self.handle_command(cmd, prompt_tx.clone()).await {
                                     Ok(ControlFlow::Break(())) => {
-
                                         if let Err(err) = task_result_tx.send(Ok(())).await {
                                             log::error!("Failed to send task result for ApplySearchFilter: {err:?}");
                                         }
                                         break
                                     },
                                     Ok(ControlFlow::Continue(())) => {
-
                                         if let Err(err) = task_result_tx.send(Ok(())).await {
                                             log::error!("Failed to send task result for ApplySearchFilter: {err:?}");
                                         }
+                                        self.senders.send_host_message(HostMessage::SessionFilterUpdated { session_id, operation_id, filters }).await;
                                     },
                                     Err(error) => {
                                         self.send_error(error).await;
@@ -212,13 +213,7 @@ impl SessionService {
                 operation_id,
                 filters,
             } => {
-                let filts = vec![SearchFilter::new("time=13".to_string(), false, true, false)];
-                println!(
-                    "☑️ Session::SessionService::handle_command: Applying search filters for session {}: {:?}",
-                    self.session_id(),
-                    filters
-                );
-                self.session.apply_search_filters(operation_id, filts)?;
+                self.session.apply_search_filters(operation_id, filters)?;
             }
             SessionCommand::DropSearch { operation_id } => {
                 if let Some(filter_op) = operation_id {

application/apps/indexer/gui/application/src/session/ui/mod.rs

@@ -90,6 +90,15 @@ impl Session {
         actions.try_send_command(&self.cmd_tx, SessionCommand::CloseSession);
     }
 
+    pub fn update_session_filters(
+        &mut self,
+        operation_id: uuid::Uuid,
+        filters: Vec<processor::search::filter::SearchFilter>,
+    ) {
+        self.shared.search.set_search_operation(operation_id);
+        self.bottom_panel.search.bar.temp_filter = filters.first().cloned();
+    }
+
     pub fn render_content(&mut self, actions: &mut UiActions, ui: &mut Ui) {
         let Self {
             logs_table,

…ation/apps/indexer/mcp/src/agents/mod.rs …pps/indexer/mcp/src/client/agents/mod.rsapplication/apps/indexer/mcp/src/agents/mod.rs renamed to application/apps/indexer/mcp/src/client/agents/mod.rs application/apps/indexer/mcp/src/agents/mod.rs renamed to application/apps/indexer/mcp/src/client/agents/mod.rs

@@ -8,7 +8,7 @@ use serde_json::Value;
 use url::Url;
 
 use super::LlmAgent;
-use crate::{agents, errors::McpError};
+use crate::errors::McpError;
 
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct Ollama {

…on/apps/indexer/mcp/src/agents/ollama.rs …/indexer/mcp/src/client/agents/ollama.rsapplication/apps/indexer/mcp/src/agents/ollama.rs renamed to application/apps/indexer/mcp/src/client/agents/ollama.rs application/apps/indexer/mcp/src/agents/ollama.rs renamed to application/apps/indexer/mcp/src/client/agents/ollama.rs

@@ -5,7 +5,6 @@ use ollama_rs::generation::{
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 
-use crate::agents::{self, open_ai};
 use crate::errors::McpError;
 
 use super::LlmAgent;
@@ -119,16 +118,16 @@ impl LlmAgent for OpenAI {
             .collect::<Vec<ToolInfo>>();
         let mut messages = history
             .iter()
-            .map(open_ai::chat_message_to_openai)
+            .map(chat_message_to_openai)
             .collect::<Vec<Value>>();
-        messages.push(open_ai::chat_message_to_openai(&ChatMessage::user(prompt)));
+        messages.push(chat_message_to_openai(&ChatMessage::user(prompt)));
 
         let tools = mcp_tools
             .iter()
-            .map(open_ai::fetch_tool_info)
+            .map(fetch_tool_info)
             .collect::<Vec<Value>>();
 
-        let request_body = open_ai::OpenAIRequest {
+        let request_body = OpenAIRequest {
             model: "gpt-4.1".to_string(),
             messages: messages,
             tools: tools,
@@ -158,15 +157,15 @@ impl LlmAgent for OpenAI {
             });
         }
 
-        let openai_response: open_ai::OpenAIResponse =
+        let openai_response: OpenAIResponse =
             response.json().await.map_err(|err| McpError::ChatError {
                 message: format!("{err:?}"),
             })?;
 
         // --- Handle response / tool calls ----------------------------------------
         log::warn!("✅ Response ID: {}", openai_response.id);
 
-        open_ai::fetch_chat_message(openai_response)
+        fetch_chat_message(openai_response)
     }
 }
 
@@ -181,7 +180,7 @@ pub fn fetch_tool_info(tool: &ToolInfo) -> Value {
     })
 }
 
-pub fn fetch_chat_message(resp: open_ai::OpenAIResponse) -> Result<ChatMessageResponse, McpError> {
+pub fn fetch_chat_message(resp: OpenAIResponse) -> Result<ChatMessageResponse, McpError> {
     let choice = resp.choices.into_iter().next().ok_or(McpError::ChatError {
         message: "Missing Choices from OpenAI Response".to_string(),
     })?;

…n/apps/indexer/mcp/src/agents/open_ai.rs …indexer/mcp/src/client/agents/open_ai.rsapplication/apps/indexer/mcp/src/agents/open_ai.rs renamed to application/apps/indexer/mcp/src/client/agents/open_ai.rs application/apps/indexer/mcp/src/agents/open_ai.rs renamed to application/apps/indexer/mcp/src/client/agents/open_ai.rs

@@ -1,6 +1,8 @@
 // pub mod conversation;
 // pub mod llm;
 
+pub mod agents;
+
 use log::{error, warn};
 use ollama_rs::generation::chat::ChatMessage;
 use rmcp::{
@@ -17,10 +19,10 @@ use tokio::{select, sync::mpsc};
 
 use crate::{
     // client::llm::{Llm, LlmClient, LlmConfig},
-    agents::{self, LlmAgent},
     errors::McpError,
     types::{Prompt, Response},
 };
+use agents::LlmAgent;
 
 // TODO:[MCP] store this in a single global location
 pub const SERVER_ADDRESS: &str = "http://127.0.0.1:8181/mcp";
@@ -126,6 +128,7 @@ impl McpClient {
                     let tools = mcp_service.list_tools(Default::default()).await?;
                     let message = format!("User prompt: {}\n\n session_id:\n{}", prompt.message, prompt.id);
 
+                    println!("mcp/client/mod.rs => Sending prompt to MCP: {message}");
                     let response = match std::env::var("LLM_AGENT")
                         .ok()
                         .map(|v| v.to_ascii_lowercase())