flowcept 0.9.6__tar.gz → 0.9.8__tar.gz

{flowcept-0.9.6 → flowcept-0.9.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flowcept
-Version: 0.9.6
+Version: 0.9.8
 Summary: Capture and query workflow provenance data using data observability
 Author: Oak Ridge National Laboratory
 License-Expression: MIT
@@ -27,6 +27,7 @@ Requires-Dist: jupyterlab; extra == 'all'
 Requires-Dist: langchain-community; extra == 'all'
 Requires-Dist: langchain-openai; extra == 'all'
 Requires-Dist: lmdb; extra == 'all'
+Requires-Dist: matplotlib; extra == 'all'
 Requires-Dist: mcp[cli]; extra == 'all'
 Requires-Dist: mlflow-skinny; extra == 'all'
 Requires-Dist: nbmake; extra == 'all'
@@ -38,6 +39,7 @@ Requires-Dist: psutil>=6.1.1; extra == 'all'
 Requires-Dist: py-cpuinfo; extra == 'all'
 Requires-Dist: pyarrow; extra == 'all'
 Requires-Dist: pymongo; extra == 'all'
+Requires-Dist: pymupdf; extra == 'all'
 Requires-Dist: pytest; extra == 'all'
 Requires-Dist: pyyaml; extra == 'all'
 Requires-Dist: redis; extra == 'all'
@@ -87,13 +89,28 @@ Requires-Dist: confluent-kafka<=2.8.0; extra == 'kafka'
 Provides-Extra: llm-agent
 Requires-Dist: langchain-community; extra == 'llm-agent'
 Requires-Dist: langchain-openai; extra == 'llm-agent'
+Requires-Dist: matplotlib; extra == 'llm-agent'
 Requires-Dist: mcp[cli]; extra == 'llm-agent'
+Requires-Dist: pymupdf; extra == 'llm-agent'
 Requires-Dist: streamlit; extra == 'llm-agent'
+Provides-Extra: llm-agent-audio
+Requires-Dist: gtts; extra == 'llm-agent-audio'
+Requires-Dist: langchain-community; extra == 'llm-agent-audio'
+Requires-Dist: langchain-openai; extra == 'llm-agent-audio'
+Requires-Dist: matplotlib; extra == 'llm-agent-audio'
+Requires-Dist: mcp[cli]; extra == 'llm-agent-audio'
+Requires-Dist: pydub; extra == 'llm-agent-audio'
+Requires-Dist: pymupdf; extra == 'llm-agent-audio'
+Requires-Dist: speechrecognition; extra == 'llm-agent-audio'
+Requires-Dist: streamlit; extra == 'llm-agent-audio'
+Requires-Dist: streamlit-mic-recorder; extra == 'llm-agent-audio'
 Provides-Extra: llm-google
 Requires-Dist: google-genai; extra == 'llm-google'
 Requires-Dist: langchain-community; extra == 'llm-google'
 Requires-Dist: langchain-openai; extra == 'llm-google'
+Requires-Dist: matplotlib; extra == 'llm-google'
 Requires-Dist: mcp[cli]; extra == 'llm-google'
+Requires-Dist: pymupdf; extra == 'llm-google'
 Requires-Dist: streamlit; extra == 'llm-google'
 Provides-Extra: lmdb
 Requires-Dist: lmdb; extra == 'lmdb'

{flowcept-0.9.6 → flowcept-0.9.8}/docs/index.rst

@@ -22,6 +22,7 @@ Flowcept
    prov_capture
    telemetry_capture
    prov_storage
+   prov_query
    schemas
    contributing
    cli-reference

flowcept-0.9.8/docs/prov_query.rst

@@ -0,0 +1,197 @@
+Provenance Querying
+====================
+
+Flowcept captures detailed provenance about workflows, tasks, and artifacts. Once captured, there are multiple ways to query this provenance depending on your needs. This guide summarizes the main mechanisms available for querying Flowcept data.
+
+.. note::
+
+    Persistence is optional in Flowcept. You can configure Flowcept to use LMDB, MongoDB or both. LMDB is a lightweight file‑based database ideal for simple tests; MongoDB provides advanced query support and is required for Flowcept’s database API and CLI queries. Flowcept can write to both backends if both are enabled.
+
+
+Querying with the Command‑Line Interface
+----------------------------------------
+
+Flowcept provides a small CLI for quick database queries. The CLI requires MongoDB to be enabled【202622579855635†L68-L96】 and accessible from your environment. After installing Flowcept, run `flowcept --help` to see all available commands and options【463846373907647†L68-L83】. The usage pattern is:
+
+.. code-block:: console
+
+    flowcept --<function-name-with-dashes> [--<arg-name-with-dashes>=<value>]
+
+Important query‑oriented commands include:
+
+* ``workflow-count`` – count tasks, workflows and objects for a given workflow ID【463846373907647†L152-L166】.
+* ``query`` – run a MongoDB query against the tasks collection, with optional projection, sorting and limit【463846373907647†L168-L190】.
+* ``get-task`` – fetch a single task document by its ID【463846373907647†L198-L207】.
+
+Here’s an example session:
+
+.. code-block:: console
+
+    # count the number of tasks, workflows and objects for a workflow
+    flowcept --workflow-count --workflow-id=123e4567-e89b-12d3-a456-426614174000
+
+    # query tasks where status is COMPLETED and only return `activity_id` and `status`
+    flowcept --query --filter='{"status": "COMPLETED"}' \
+            --project='{"activity_id": 1, "status": 1, "_id": 0}' \
+            --sort='[["started_at", -1]]' --limit=10
+
+    # fetch a task by ID
+    flowcept --get-task --task-id=24aa4e52-9aec-4ef6-8cb7-cbd7c72d436e
+
+The CLI prints JSON results to stdout. For full usage details see the official CLI reference【463846373907647†L68-L83】.
+
+Querying via the Python API (`Flowcept.db`)
+-------------------------------------------
+
+For programmatic access inside scripts and notebooks, Flowcept exposes a database API via the ``Flowcept.db`` property. When MongoDB is enabled this property returns an instance of the internal `DBAPI` class. You can call any of the following methods:
+
+* ``task_query(filter, projection=None, limit=0, sort=None)`` – query the `tasks` collection with an optional projection, sort and limit.
+* ``workflow_query(filter)`` – query the `workflows` collection.
+* ``get_workflow_object(workflow_id)`` – fetch a workflow and return a `WorkflowObject`.
+* ``insert_or_update_task(task_object)`` – insert or update a task.
+* ``save_or_update_object(object, type, custom_metadata, …)`` – persist binary objects such as models or large artifacts.
+
+Below is a typical usage pattern:
+
+.. code-block:: python
+
+    from flowcept import Flowcept
+
+    # query tasks for the current workflow
+    tasks = Flowcept.db.get_tasks_from_current_workflow()
+    print(f"Tasks captured in current workflow: {len(tasks)}")
+
+    # find all tasks marked with a "math" tag
+    math_tasks = Flowcept.db.task_query(filter={"tags": "math"})
+    for t in math_tasks:
+        print(f"{t['task_id']} – {t['activity_id']}: {t['status']}")
+
+    # fetch a workflow object and inspect its arguments
+    wf = Flowcept.db.get_workflow_object(workflow_id="123e4567-e89b-12d3-a456-426614174000")
+    print(wf.workflow_args)
+
+The `DBAPI` exposes many other methods, such as `get_tasks_recursive` to retrieve all descendants of a task, or `dump_tasks_to_file_recursive` to export tasks to Parquet. See the API reference for details.
+
+Accessing the In‑Memory Buffer
+------------------------------
+
+During runtime Flowcept stores captured messages in an in‑memory buffer (`Flowcept.buffer`). This buffer is useful for debugging or lightweight scripts because it provides immediate access to the latest tasks and workflows without any additional services. In the example below we create two tasks that attach binary data and then inspect the buffer:
+
+.. code-block:: python
+
+    from pathlib import Path
+    from flowcept import Flowcept
+    from flowcept.instrumentation.task import FlowceptTask
+
+    with Flowcept() as f:
+        used_args = {"a": 1}
+        # first task – attach a PDF
+        with FlowceptTask(used=used_args) as t:
+            img_path = Path("docs/img/architecture.pdf")
+            with open(img_path, "rb") as fp:
+                img_data = fp.read()
+            t.end(generated={"b": 2},
+                  data=img_data,
+                  custom_metadata={
+                      "mime_type": "application/pdf",
+                      "file_name": "architecture.pdf",
+                      "file_extension": "pdf"})
+            t.send()
+        # second task – attach a PNG
+        with FlowceptTask(used=used_args) as t:
+            img_path = Path("docs/img/flowcept-logo.png")
+            with open(img_path, "rb") as fp:
+                img_data = fp.read()
+            t.end(generated={"c": 2},
+                  data=img_data,
+                  custom_metadata={
+                      "mime_type": "image/png",
+                      "file_name": "flowcept-logo.png",
+                      "file_extension": "png"})
+            t.send()
+
+        # inspect the buffer
+        assert len(Flowcept.buffer) == 3  # includes the workflow message
+        assert Flowcept.buffer[1]["data"]  # binary data is captured as bytes
+
+At any point inside the running workflow you can access `Flowcept.buffer` to retrieve a list of dictionaries representing messages. Each element contains the original JSON payload plus any binary `data` field. Because the buffer lives in memory, it reflects the most recent state of the workflow and is cleared when the process ends.
+
+Working Offline: Reading a Messages File
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+When persistence is enabled in offline mode, Flowcept dumps the buffer to a JSONL file. Use :func:`Flowcept.read_messages_file` to load these messages later. If you pass `return_df=True` Flowcept will normalise nested fields into dot‑separated columns and return a pandas DataFrame. This is handy for ad‑hoc analysis with pandas.
+
+.. code-block:: python
+
+    from flowcept import Flowcept
+
+    # read JSON into a list of dicts
+    msgs = Flowcept.read_messages_file("offline_buffer.jsonl")
+    print(f"{len(msgs)} messages")
+
+    # read JSON into a pandas DataFrame
+    df = Flowcept.read_messages_file("offline_buffer.jsonl", return_df=True)
+    # dot‑notation columns allow easy selection; e.g., outputs of attention layers
+    print("generated.attention" in df.columns)
+
+Keep in mind that the JSONL file is only created when using fully offline mode. The path is configured in the settings file under ``DUMP_BUFFER_PATH``. If the file doesn’t exist, `read_messages_file` will raise an error.
+
+
+Working Directly with MongoDB
+-----------------------------
+
+If MongoDB is enabled in your settings you may prefer to query the database directly, especially for complex aggregation pipelines. Flowcept stores tasks in the ``tasks`` collection, workflows in ``workflows``, and binary objects in ``objects``. You can use any MongoDB tool or client library, such as:
+
+* **PyMongo** – Python driver for MongoDB; perfect for custom scripts.
+* **MongoDB Compass** – graphical UI for ad‑hoc queries and visualisation.
+* **mongo shell** or **mongosh** – CLI for interactive queries.
+
+For example, using PyMongo:
+
+.. code-block:: python
+
+    import pymongo
+
+    client = pymongo.MongoClient("mongodb://localhost:27017")
+    db = client["flowcept"]
+    # find the 20 most recent tasks for a workflow
+    tasks = db.tasks.find(
+        {"workflow_id": "123e4567-e89b-12d3-a456-426614174000"},
+        {"_id": 0, "activity_id": 1, "status": 1}
+    ).sort("started_at", pymongo.DESCENDING).limit(20)
+    for t in tasks:
+        print(t)
+
+The connection string, database name and authentication credentials are configured in the Flowcept settings file.
+
+Working with LMDB
+-----------------
+
+If LMDB is enabled instead of MongoDB【202622579855635†L68-L96】 Flowcept stores data in a directory (default: ``flowcept_lmdb``). LMDB is a file‑based key–value store; it does not support ad‑hoc queries out of the box, but you can read the data programmatically. Flowcept’s `DBAPI` can export LMDB data into pandas DataFrames, allowing you to analyse offline runs without MongoDB:
+
+.. code-block:: python
+
+    from flowcept import Flowcept
+
+    # export LMDB tasks to a DataFrame
+    df = Flowcept.db.to_df(collection="tasks")
+    print(df.head())
+
+Alternatively, you can use the `lmdb` Python library to iterate over raw key–value pairs. The LMDB environment is located under the directory configured in your settings file (commonly named ``flowcept_lmdb``). Because LMDB stores binary values, you’ll need to serialise and deserialise JSON messages yourself.
+
+Monitoring Provenance with Grafana
+----------------------------------
+
+Flowcept supports streaming provenance into monitoring dashboards. A sample Docker compose file (`deployment/compose-grafana.yml`) runs Grafana along with MongoDB and Redis. Grafana is configured with a pre‑built MongoDB‑Grafana image and exposes a port (3000) for the dashboard【711366042692702†L292-L297】. To configure Grafana to query Flowcept’s MongoDB, create a new data source with the URL `mongodb://flowcept_mongo:27017` and specify the database name (usually `flowcept`). The compose file sets environment variables for the admin user and password so you can log in and create your own panels.
+
+Grafana can also connect directly to Redis or Kafka for near‑real‑time streaming. See the Grafana documentation for instructions on configuring those plugins.
+
+Querying via the LLM‑based Flowcept Agent
+-----------------------------------------
+
+Flowcept’s agentic querying (powered by language models) is under active development. The agent will allow natural‑language queries over provenance data, with interactive guidance and summarisation. Documentation will be released in a future version. In the meantime, use the CLI or Python API for querying tasks and workflows.
+
+Conclusion
+----------
+
+Flowcept offers several ways to query provenance data depending on your environment and requirements. For quick inspection, use the in‑memory buffer or offline message files. For interactive scripts or notebooks, `Flowcept.db` provides a high‑level API to MongoDB or LMDB. For more sophisticated queries, connect directly to MongoDB using the CLI or standard MongoDB tools. Grafana integration lets you build dashboards on live data. As Flowcept evolves, additional capabilities—such as LLM‑based query agents—will expand the ways you can explore your provenance.

flowcept-0.9.8/docs/task_schema.rst

@@ -0,0 +1,157 @@
+Task Data Schema
+================
+
+This document describes the schema of a task record used to capture metadata, telemetry, and provenance in a workflow. 
+A task represents one unit of work, including inputs, outputs, execution context, system telemetry, and runtime provenance.
+
+Each task record may include fields for identifiers, timing, telemetry, user and system context, dependencies, and custom metadata.
+
+Task Fields
+-----------
+
+- **type**: Constant type label (``"task"``) (string)
+- **subtype**: Optional subtype of the task, e.g., iteration, ML step, custom (string)
+
+Identifiers
+~~~~~~~~~~~
+
+- **task_id**: Unique identifier for the task (string)
+- **workflow_id**: Identifier for the workflow this task belongs to (string)
+- **workflow_name**: Name of the workflow this task belongs to (string)
+- **campaign_id**: Identifier for the campaign this task belongs to (string)
+- **activity_id**: Identifier for the activity performed by the task (usually a function name) (string)
+- **group_id**: Identifier grouping related tasks, e.g., loop iterations (string)
+- **parent_task_id**: Identifier of the parent task, if nested (string)
+- **agent_id**: Identifier of the agent responsible for executing the task (string)
+- **adapter_id**: Identifier of the adapter that produced this task (string)
+- **environment_id**: Identifier of the environment where the task ran (string)
+
+Timing
+~~~~~~
+
+- **utc_timestamp**: UTC timestamp when the task object was created (float)
+- **submitted_at**: Timestamp when the task was submitted (float)
+- **started_at**: Timestamp when execution started (float)
+- **ended_at**: Timestamp when execution ended (float)
+- **registered_at**: Timestamp when registered in storage (float)
+
+Provenance Data
+~~~~~~~~~~~~~~~
+
+- **used**: Inputs consumed by the task, such as parameters, files, or resources (dictionary)
+- **generated**: Outputs produced by the task, e.g., results, artifacts, files (dictionary)
+- **dependencies**: List of task IDs this task depends on (list)
+- **dependents**: List of task IDs that depend on this task (list)
+
+Execution Metadata
+~~~~~~~~~~~~~~~~~~
+
+- **status**: Execution status of the task (e.g., FINISHED, ERROR) (string)
+- **stdout**: Captured standard output (string or dictionary)
+- **stderr**: Captured standard error (string or dictionary)
+- **data**: Arbitrary raw payload associated with the task (any type)
+- **custom_metadata**: User- or developer-provided metadata dictionary (dictionary)
+- **tags**: User-defined tags attached to the task (list)
+
+User and System Context
+~~~~~~~~~~~~~~~~~~~~~~~
+
+- **user**: User who executed or triggered the task (string)
+- **login_name**: Login name of the user in the environment (string)
+- **node_name**: Node where the task executed (string)
+- **hostname**: Hostname of the machine executing the task (string)
+- **public_ip**: Public IP address (string)
+- **private_ip**: Private IP address (string)
+- **address**: Optional network address (string)
+- **mq_host**: Message queue host associated with the task (string)
+
+Telemetry Data Schema
+---------------------
+
+If telemetry capture is enabled, telemetry snapshots are stored in ``telemetry_at_start`` and ``telemetry_at_end``. 
+Each is a dictionary with the following structure:
+
+CPU
+~~~
+
+- **times_avg**: Dictionary with CPU times
+  - **user**, **nice**, **system**, **idle**
+- **percent_all**: Overall CPU usage percentage
+- **frequency**: CPU frequency
+- **times_per_cpu**: List of dictionaries of per-core times
+- **percent_per_cpu**: List of per-core usage percentages
+
+Process
+~~~~~~~
+
+- **pid**: Process ID
+- **memory**: Dictionary with memory stats
+  - **rss**, **vms**, **pfaults**, **pageins**
+- **memory_percent**: Memory usage percentage
+- **cpu_times**: Dictionary with CPU times
+  - **user**, **system**, **children_user**, **children_system**
+- **cpu_percent**: CPU usage percentage
+- **executable**: Path to executable
+- **cmd_line**: Command line arguments
+- **num_open_file_descriptors**, **num_connections**, **num_open_files**, **num_threads**
+- **num_ctx_switches**: Dictionary with
+  - **voluntary**, **involuntary**
+
+Memory
+~~~~~~
+
+- **virtual**: Dictionary with virtual memory stats
+  - **total**, **available**, **percent**, **used**, **free**, **active**, **inactive**, **wired**
+- **swap**: Dictionary with swap memory stats
+  - **total**, **used**, **free**, **percent**, **sin**, **sout**
+
+Disk
+~~~~
+
+- **disk_usage**: Dictionary with usage stats
+  - **total**, **used**, **free**, **percent**
+- **io_sum**: Dictionary with I/O stats
+  - **read_count**, **write_count**, **read_bytes**, **write_bytes**, **read_time**, **write_time**
+
+Network
+~~~~~~~
+
+- **netio_sum**: Dictionary with aggregate network I/O
+  - **bytes_sent**, **bytes_recv**, **packets_sent**, **packets_recv**, **errin**, **errout**, **dropin**, **dropout**
+- **netio_per_interface**: Dictionary keyed by interface with same metrics
+
+GPU
+~~~
+
+GPU telemetry data, if available, is in the ``gpu`` field. Structure depends on vendor.
+
+**Common Fields**
+
+- **gpu_ix**: GPU index (int)
+- **used**: Memory used (bytes)
+- **temperature**: Dictionary or integer temperature
+- **power**: Dictionary or value of power usage
+- **id**: Device UUID
+- **name**: GPU name (NVIDIA only)
+- **activity**: GPU activity percentage (AMD only)
+- **others**: Clock/performance data (AMD only)
+
+**AMD GPU**
+
+- **temperature**: edge, hotspot, mem, vrgfx, vrmem, hbm, fan_speed
+- **power**: average_socket_power, energy_accumulator
+- **others**: current_gfxclk, current_socclk, current_uclk, current_vclk0, current_dclk0
+
+**NVIDIA GPU**
+
+- **temperature**: Celsius value
+- **power**: Milliwatts usage
+- **used**: Memory used (bytes)
+- **name**: Model name
+- **id**: Device UUID
+
+Notes
+-----
+
+Telemetry values vary depending on system capabilities, GPU vendor APIs, 
+and what is enabled in the configuration.

{flowcept-0.9.6 → flowcept-0.9.8}/pyproject.toml

@@ -65,8 +65,14 @@ mlflow = ["mlflow-skinny", "SQLAlchemy", "alembic", "watchdog", "cryptography"]
 nvidia = ["nvidia-ml-py"]
 mqtt = ["paho-mqtt"]
 tensorboard = ["tensorboard", "tensorflow", "tbparse"]
-llm_agent = ["mcp[cli]", "langchain_community", "streamlit", "langchain_openai"]
+llm_agent = ["mcp[cli]", "langchain_community", "langchain_openai", "streamlit", "PyMuPDF", "matplotlib"]
 llm_google = ["flowcept[llm_agent]", "google-genai"]
+llm_agent_audio = ["flowcept[llm_agent]", "streamlit-mic-recorder", "SpeechRecognition", "pydub", "gTTS"]
+# System dependency (required for pydub)
+# Install ffmpeg on the system (not a pip package):
+# macOS (Homebrew): brew install ffmpeg
+# Conda (any OS): conda install -c conda-forge ffmpeg
+# Debian/Ubuntu: sudo apt-get install ffmpeg
 
 dev = [
     "flowcept[docs]",

{flowcept-0.9.6 → flowcept-0.9.8}/resources/sample_settings.yaml

@@ -1,4 +1,4 @@
-flowcept_version: 0.9.6 # Version of the Flowcept package. This setting file is compatible with this version.
+flowcept_version: 0.9.8 # Version of the Flowcept package. This setting file is compatible with this version.
 
 project:
   debug: true # Toggle debug mode. This will add a property `debug: true` to all saved data, making it easier to retrieve/delete them later.
@@ -91,6 +91,7 @@ agent:
   model: '?'
   service_provider: '?'
   model_kwargs: {}
+  audio_enabled: false
 
 databases:
 

{flowcept-0.9.6 → flowcept-0.9.8}/src/flowcept/agents/gui/agent_gui.py

@@ -1,76 +1,87 @@
 import streamlit as st
+
 from flowcept.agents.gui import AI, PAGE_TITLE
+from flowcept.agents.gui.audio_utils import get_audio_text
 from flowcept.agents.gui.gui_utils import (
     query_agent,
     display_ai_msg,
     display_ai_msg_from_tool,
     display_df_tool_response,
+    resolve_logo_path,
+    render_title_with_logo,
 )
-
 from flowcept.agents.tools.in_memory_queries.in_memory_queries_tools import (
     generate_result_df,
     generate_plot_code,
     run_df_code,
 )
+from flowcept.configs import AGENT_AUDIO
 
+# ---- Page setup & header with logo ----
 st.set_page_config(page_title=PAGE_TITLE, page_icon=AI)
-st.title(PAGE_TITLE)
+
+LOGO_PATH = resolve_logo_path(package="flowcept", resource="docs/img/flowcept-logo.png")
+render_title_with_logo(PAGE_TITLE, LOGO_PATH, logo_width=150, add_to_sidebar=False, debug=False)
 
 GREETING = (
-    "Hi, there! I'm a **Workflow Provenance Specialist**.\n\n"
+    "Hi, there! I'm your **Workflow Provenance Assistant**.\n\n"
     "I am tracking workflow executions and I can:\n"
-    "- 🔍 Analyze running workflows\n"
+    "- 🔍 Query running workflows\n"
     "- 📊 Plot graphs\n"
     "- 🤖 Answer general questions about provenance data\n\n"
     "How can I help you today?"
 )
-
-
 display_ai_msg(GREETING)
 
-# if "chat_history" not in st.session_state:
-#     st.session_state.chat_history = [{"role": "system", "content":GREETING}]
-#
-# for msg in st.session_state.chat_history:
-#     with st.chat_message(msg["role"], avatar=AI):
-#         st.markdown(msg["content"])
-
 
 def main():
-    """Main Streamlit Function."""
+    """Main Agent GUI function."""
+    st.caption(
+        "💡 Tip: Ask about workflow metrics, generate plots, or summarize data. "
+        "Inputs are mapped to `used` and outputs to `generated` fields. "
+        "Use @record <your query guidance> if you have custom guidance."
+    )
+
     user_input = st.chat_input("Send a message")
-    st.caption("💡 Tip: Ask about workflow metrics, generate plots, or summarize data.")
 
     if user_input:
-        # st.session_state.chat_history.append({"role": "human", "content": user_input})
+        st.session_state["speak_reply"] = False
+
+    if AGENT_AUDIO:
+        user_input = get_audio_text(user_input)
 
+    if user_input:
         with st.chat_message("human"):
             st.markdown(user_input)
 
         try:
             with st.spinner("🤖 Thinking..."):
                 tool_result = query_agent(user_input)
-            print(tool_result)
 
             if tool_result.result_is_str():
                 display_ai_msg_from_tool(tool_result)
+
             elif tool_result.is_success_dict():
                 tool_name = tool_result.tool_name
-                if tool_name in [generate_result_df.__name__, generate_plot_code.__name__, run_df_code.__name__]:
+                if tool_name in (
+                    generate_result_df.__name__,
+                    generate_plot_code.__name__,
+                    run_df_code.__name__,
+                ):
                     display_df_tool_response(tool_result)
                 else:
                     display_ai_msg(f"⚠️ Received unexpected response from agent: {tool_result}")
                     st.stop()
             else:
                 display_df_tool_response(tool_result)
-                # display_ai_msg(f"⚠️ Received unexpected response from agent: {tool_result}")
                 st.stop()
 
         except Exception as e:
             display_ai_msg(f"❌ Error talking to MCP agent:\n\n```text\n{e}\n```")
             st.stop()
 
-        # st.session_state.chat_history.append({"role": "system", "content": agent_reply})
 
+if "speak_reply" not in st.session_state:
+    st.session_state["speak_reply"] = False
 
 main()