flowcept 0.8.11__py3-none-any.whl → 0.9.1__py3-none-any.whl

flowcept/flowceptor/adapters/agents/agents_utils.py

@@ -1,89 +0,0 @@
-from typing import List, Union
-
-from langchain_community.llms.sambanova import SambaStudio
-from mcp.server.fastmcp.prompts import base
-from langchain_core.language_models import LLM
-from langchain_core.messages import HumanMessage, AIMessage
-
-from flowcept.configs import AGENT
-
-
-def build_llm_model() -> LLM:
-    """
-    Build and return an LLM instance using agent configuration.
-
-    This function retrieves the model name and keyword arguments from the AGENT configuration,
-    constructs a SambaStudio LLM instance, and returns it.
-
-    Returns
-    -------
-    LLM
-        An initialized LLM object configured using the `AGENT` settings.
-    """
-    model_kwargs = AGENT.get("model_kwargs").copy()
-    model_kwargs["model"] = AGENT.get("model")
-    llm = SambaStudio(model_kwargs=model_kwargs)
-
-    return llm
-
-
-def convert_mcp_messages_to_plain_text(messages: list[base.Message]) -> str:
-    """
-    Convert a list of MCP base.Message objects into a plain text dialogue.
-
-    Parameters
-    ----------
-    messages : list of BaseMessage
-        The list of messages, typically from HumanMessage, AIMessage, SystemMessage, etc.
-
-    Returns
-    -------
-    str
-        A plain text version of the conversation, with roles labeled.
-    """
-    lines = []
-    for message in messages:
-        role = message.role.capitalize()  # e.g., "human" → "Human"
-        line = f"{role}: {message.content.text}"
-        lines.append(line)
-    return "\n".join(lines)
-
-
-def convert_mcp_to_langchain(messages: list[base.Message]) -> List[Union[HumanMessage, AIMessage]]:
-    """
-    Convert a list of MCP-style messages to LangChain-compatible message objects.
-
-    Parameters
-    ----------
-    messages : list of base.Message
-        A list of messages in the MCP message format, each with a `role` and `content`.
-
-    Returns
-    -------
-    list of Union[HumanMessage, AIMessage]
-        A list of LangChain message objects, converted from the original MCP format.
-
-    Raises
-    ------
-    ValueError
-        If a message has a role that is not 'user' or 'assistant'.
-
-    Notes
-    -----
-    This function extracts the `text` attribute from message content if present, falling back to `str(content)`
-    otherwise. It maps MCP 'user' roles to LangChain `HumanMessage` and 'assistant' roles to `AIMessage`.
-    """
-    converted = []
-    for m in messages:
-        if hasattr(m.content, "text"):
-            content = m.content.text
-        else:
-            content = str(m.content)  # fallback if it's already a string
-
-        if m.role == "user":
-            converted.append(HumanMessage(content=content))
-        elif m.role == "assistant":
-            converted.append(AIMessage(content=content))
-        else:
-            raise ValueError(f"Unsupported role: {m.role}")
-    return converted

flowcept/flowceptor/adapters/agents/flowcept_agent.py

@@ -1,292 +0,0 @@
-import json
-import os
-from typing import Dict, List
-
-import uvicorn
-from langchain.chains.retrieval_qa.base import RetrievalQA
-from mcp.server.fastmcp import FastMCP
-from mcp.server.fastmcp.prompts import base
-
-from flowcept.configs import AGENT
-from flowcept.flowcept_api.flowcept_controller import Flowcept
-from flowcept.flowceptor.adapters.agents.agents_utils import (
-    convert_mcp_to_langchain,
-    convert_mcp_messages_to_plain_text,
-)
-from flowcept.flowceptor.adapters.agents.flowcept_llm_prov_capture import (
-    invoke_llm,
-    invoke_qa_question,
-    add_preamble_to_response,
-)
-from flowcept.flowceptor.adapters.agents.prompts import (
-    get_question_prompt,
-    BASE_MULTITASK_PROMPT,
-    BASE_SINGLETASK_PROMPT,
-)
-from flowcept.flowceptor.consumers.agent.flowcept_agent_context_manager import FlowceptAgentContextManager
-from flowcept.flowceptor.consumers.agent.flowcept_qa_manager import FlowceptQAManager
-
-os.environ["SAMBASTUDIO_URL"] = AGENT.get("llm_server_url")
-os.environ["SAMBASTUDIO_API_KEY"] = AGENT.get("api_key")
-
-agent_controller = FlowceptAgentContextManager()
-mcp = FastMCP("FlowceptAgent", require_session=True, lifespan=agent_controller.lifespan)
-
-#################################################
-# PROMPTS
-#################################################
-
-
-@mcp.prompt()
-def single_task_used_generated_prompt(task_data: Dict, question: str) -> list[base.Message]:
-    """
-    Generate a prompt for analyzing a single task's provenance and resource usage.
-
-    Parameters
-    ----------
-    task_data : dict
-        The task object containing provenance and telemetry fields.
-    question : str
-        A specific question to ask about the task.
-
-    Returns
-    -------
-    list of base.Message
-        The structured prompt messages for LLM analysis.
-    """
-    msgs = BASE_SINGLETASK_PROMPT.copy()
-    msgs.append(get_question_prompt(question))
-    msgs.append(base.UserMessage(f"This is the task object I need you to focus on: \n {task_data}\n"))
-    return msgs
-
-
-@mcp.prompt()
-def multi_task_summary_prompt(task_list: List[Dict]) -> List[base.Message]:
-    """
-    Generate a prompt for analyzing multiple task objects in a workflow.
-
-    Parameters
-    ----------
-    task_list : list of dict
-        A list of task objects with provenance and telemetry data.
-
-    Returns
-    -------
-    list of base.Message
-        The structured prompt messages for the LLM.
-    """
-    messages = BASE_MULTITASK_PROMPT.copy()
-    pretty_tasks = json.dumps(task_list, indent=2, default=str)
-    messages.append(base.UserMessage(f"These are the tasks I need you to reason about:\n\n{pretty_tasks}\n\n"))
-    return messages
-
-
-@mcp.prompt()
-def multi_task_qa_prompt(question: str) -> List[base.Message]:
-    """
-    Generate a prompt for asking a specific question about multiple tasks.
-
-    Parameters
-    ----------
-    question : str
-        The user's query about task data.
-
-    Returns
-    -------
-    list of base.Message
-        Prompt messages structured for the LLM.
-    """
-    messages = BASE_MULTITASK_PROMPT.copy()
-    messages.append(get_question_prompt(question))
-    return messages
-
-
-#################################################
-# TOOLS
-#################################################
-
-
-@mcp.tool()
-def analyze_task_chunk() -> str:
-    """
-    Analyze a recent chunk of tasks using an LLM to detect patterns or anomalies.
-
-    Returns
-    -------
-    str
-        LLM-generated analysis of the selected task chunk.
-    """
-    LAST_K = 5  # TODO make this dynamic from config
-    ctx = mcp.get_context()
-    task_list = ctx.request_context.lifespan_context.task_summaries[:-LAST_K]
-    agent_controller.logger.debug(f"N Tasks = {len(task_list)}")
-    if not task_list:
-        return "No tasks available."
-
-    messages = multi_task_summary_prompt(task_list)
-    langchain_messages = convert_mcp_to_langchain(messages)
-    response = invoke_llm(langchain_messages)
-    result = add_preamble_to_response(response, mcp, task_data=None)
-    agent_controller.logger.debug(f"Result={result}")
-    return result
-
-
-@mcp.tool()
-def ask_about_tasks_buffer(question: str) -> str:
-    """
-    Use a QA chain to answer a question about the current task buffer.
-
-    Parameters
-    ----------
-    question : str
-        The question to ask about the buffered tasks.
-
-    Returns
-    -------
-    str
-        Answer from the QA chain or an error message.
-    """
-    ctx = mcp.get_context()
-    qa_chain = build_qa_chain_from_ctx(ctx)
-    if not qa_chain:
-        return "No tasks available."
-
-    messages = multi_task_qa_prompt(question)
-
-    try:
-        query_str = convert_mcp_messages_to_plain_text(messages)
-    except Exception as e:
-        agent_controller.logger.exception(e)
-        return f"An internal error happened: {e}"
-
-    response = invoke_qa_question(qa_chain, query_str=query_str)
-    agent_controller.logger.debug(f"Response={response}")
-    return response
-
-
-def build_qa_chain_from_ctx(ctx) -> RetrievalQA:
-    """
-    Build or retrieve a QA chain from the current request context.
-
-    Parameters
-    ----------
-    ctx : RequestContext
-        The current MCP request context.
-
-    Returns
-    -------
-    RetrievalQA or None
-        A QA chain built from vectorstore metadata, or None if unavailable.
-    """
-    qa_chain = ctx.request_context.lifespan_context.qa_chain
-    if not qa_chain:
-        vectorstore_path = ctx.request_context.lifespan_context.vectorstore_path
-        if not vectorstore_path:
-            return None
-        agent_controller.logger.debug(f"Path: {vectorstore_path}")
-        qa_chain = FlowceptQAManager.build_qa_chain_from_vectorstore_path(vectorstore_path)
-        if not qa_chain:
-            return None
-    return qa_chain
-
-
-@mcp.tool()
-def get_latest(n: int = None) -> str:
-    """
-    Return the most recent task(s) from the task buffer.
-
-    Parameters
-    ----------
-    n : int, optional
-        Number of most recent tasks to return. If None, return only the latest.
-
-    Returns
-    -------
-    str
-        JSON-encoded task(s).
-    """
-    ctx = mcp.get_context()
-    tasks = ctx.request_context.lifespan_context.tasks
-    if not tasks:
-        return "No tasks available."
-    if n is None:
-        return json.dumps(tasks[-1])
-    return json.dumps(tasks[-n])
-
-
-@mcp.tool()
-def check_liveness() -> str:
-    """
-    Confirm the agent is alive and responding.
-
-    Returns
-    -------
-    str
-        Liveness status string.
-    """
-    return f"I'm {mcp.name} and I'm ready!"
-
-
-@mcp.tool()
-def check_llm() -> str:
-    """
-    Check connectivity and response from the LLM backend.
-
-    Returns
-    -------
-    str
-        LLM response, formatted with MCP metadata.
-    """
-    messages = [base.UserMessage("Hi, are you working properly?")]
-
-    langchain_messages = convert_mcp_to_langchain(messages)
-    response = invoke_llm(langchain_messages)
-    result = add_preamble_to_response(response, mcp)
-
-    return result
-
-
-@mcp.tool()
-def ask_about_latest_task(question) -> str:
-    """
-    Ask a question specifically about the latest task in the buffer.
-
-    Parameters
-    ----------
-    question : str
-        A user-defined question to analyze the latest task.
-
-    Returns
-    -------
-    str
-        Response from the LLM based on the latest task.
-    """
-    ctx = mcp.get_context()
-    tasks = ctx.request_context.lifespan_context.task_summaries
-    if not tasks:
-        return "No tasks available."
-    task_data = tasks[-1]
-
-    messages = single_task_used_generated_prompt(task_data, question)
-
-    langchain_messages = convert_mcp_to_langchain(messages)
-
-    response = invoke_llm(langchain_messages)
-    result = add_preamble_to_response(response, mcp, task_data)
-    return result
-
-
-def main():
-    """
-    Start the MCP server.
-    """
-    f = Flowcept(start_persistence=False, save_workflow=False, check_safe_stops=False).start()
-    f.logger.info(f"This section's workflow_id={Flowcept.current_workflow_id}")
-    setattr(mcp, "workflow_id", f.current_workflow_id)
-    uvicorn.run(
-        mcp.streamable_http_app, host=AGENT.get("mcp_host", "0.0.0.0"), port=AGENT.get("mcp_port", 8000), lifespan="on"
-    )
-
-
-if __name__ == "__main__":
-    main()

flowcept/flowceptor/adapters/agents/flowcept_llm_prov_capture.py

@@ -1,186 +0,0 @@
-import inspect
-import json
-from typing import List, Union, Dict
-
-from langchain.chains.retrieval_qa.base import RetrievalQA
-from langchain_community.callbacks import get_openai_callback
-from langchain_core.language_models import LLM
-from langchain_core.messages import HumanMessage, AIMessage
-
-from flowcept.flowceptor.adapters.agents.agents_utils import build_llm_model
-from flowcept.instrumentation.task_capture import FlowceptTask
-
-
-def add_preamble_to_response(response, mcp, task_data=None):
-    """
-    Add workflow/task-related metadata as a preamble to the LLM response.
-
-    Parameters
-    ----------
-    response : str
-        The LLM response text.
-    mcp : Any
-        The agent or workflow object, expected to have an optional `workflow_id` attribute.
-    task_data : dict, optional
-        Dictionary containing task metadata such as `workflow_id` and `task_id`.
-
-    Returns
-    -------
-    str
-        The response string prefixed with workflow/task metadata.
-    """
-    preamb_obj = {}
-    if hasattr(mcp, "workflow_id"):
-        agent_id = getattr(mcp, "workflow_id")
-        preamb_obj["agent_id"] = agent_id
-    if task_data:
-        preamb_obj["workflow_id"] = task_data.get("workflow_id")
-        preamb_obj["task_id"] = task_data.get("task_id")
-    result = ""
-    if preamb_obj:
-        result = f"{json.dumps(preamb_obj)}\n\n"
-    result += f"Response:\n{response}"
-    return result
-
-
-def invoke_llm(messages: List[Union[HumanMessage, AIMessage]], llm: LLM = None, activity_id=None) -> str:
-    """
-    Invoke an LLM with a list of chat-style messages and return its response.
-
-    Parameters
-    ----------
-    messages : List[Union[HumanMessage, AIMessage]]
-        The list of messages forming the conversation history for the LLM.
-    llm : LLM, optional
-        An instance of a LangChain-compatible LLM. If None, a default model is built.
-    activity_id : str, optional
-        An optional identifier for the activity, used for Flowcept instrumentation.
-
-    Returns
-    -------
-    str
-        The LLM's text response.
-    """
-    if llm is None:
-        llm = build_llm_model()
-    if activity_id is None:
-        activity_id = inspect.stack()[1].function
-
-    used = {"messages": [{"role": msg.type, "content": msg.content} for msg in messages]}
-
-    llm_metadata = _extract_llm_metadata(llm)
-
-    with FlowceptTask(
-        activity_id=activity_id,
-        used=used,
-        custom_metadata={"llm_metadata": llm_metadata, "query_type": "llm_invoke"},
-        subtype="llm_query",
-    ) as t:
-        with get_openai_callback() as cb:
-            response = llm.invoke(messages)
-            generated = {
-                "text_response": response,
-                "total_tokens": cb.total_tokens,
-                "prompt_tokens": cb.prompt_tokens,
-                "completion_tokens": cb.completion_tokens,
-                "cost": cb.total_cost,
-            }
-            t.end(generated)
-            return response
-
-
-def invoke_qa_question(qa_chain: RetrievalQA, query_str: str, activity_id=None) -> str:
-    """
-    Query a RetrievalQA chain with a given question and return the response.
-
-    Parameters
-    ----------
-    qa_chain : RetrievalQA
-        The QA chain object to invoke.
-    query_str : str
-        The question to ask the QA chain.
-    activity_id : str, optional
-        An optional identifier for the activity, used for Flowcept instrumentation.
-
-    Returns
-    -------
-    str
-        The textual result from the QA chain.
-    """
-    used = {"message": query_str}
-    qa_chain_metadata = _extract_qa_chain_metadata(qa_chain)
-    with FlowceptTask(
-        activity_id=activity_id,
-        used=used,
-        subtype="llm_query",
-        custom_metadata={"qa_chain_metadata": qa_chain_metadata, "query_type": "qa_chain"},
-    ) as t:
-        with get_openai_callback() as cb:
-            response = dict(qa_chain({"query": f"{query_str}"}))  # TODO bug?
-            text_response = response.pop("result")
-            generated = {
-                "response": response,
-                "text_response": text_response,
-                "total_tokens": cb.total_tokens,
-                "prompt_tokens": cb.prompt_tokens,
-                "completion_tokens": cb.completion_tokens,
-                "cost": cb.total_cost,
-            }
-            t.end(generated)
-            return text_response
-
-
-def _extract_llm_metadata(llm: LLM) -> Dict:
-    """
-    Extract metadata from a LangChain LLM instance.
-
-    Parameters
-    ----------
-    llm : LLM
-        The language model instance.
-
-    Returns
-    -------
-    dict
-        Dictionary containing class name, module, model name, and configuration if available.
-    """
-    llm_metadata = {
-        "class_name": llm.__class__.__name__,
-        "module": llm.__class__.__module__,
-        "config": llm.dict() if hasattr(llm, "dict") else {},
-    }
-    return llm_metadata
-
-
-def _extract_qa_chain_metadata(qa_chain: RetrievalQA) -> Dict:
-    """
-    Extract metadata from a RetrievalQA chain, including LLM and retriever details.
-
-    Parameters
-    ----------
-    qa_chain : RetrievalQA
-        The QA chain to extract metadata from.
-
-    Returns
-    -------
-    dict
-        Metadata dictionary including QA chain class name, retriever details, and optionally LLM metadata.
-    """
-    retriever = getattr(qa_chain, "retriever", None)
-    retriever_metadata = {
-        "class_name": retriever.__class__.__name__ if retriever else None,
-        "module": retriever.__class__.__module__ if retriever else None,
-        "vectorstore_type": getattr(retriever, "vectorstore", None).__class__.__name__
-        if hasattr(retriever, "vectorstore")
-        else None,
-        "retriever_config": retriever.__dict__ if retriever else {},
-    }
-    metadata = {
-        "qa_chain_class": qa_chain.__class__.__name__,
-        "retriever": retriever_metadata,
-    }
-    llm = getattr(qa_chain, "llm", None)
-    if llm:
-        metadata["llm"] = _extract_llm_metadata(llm)
-
-    return metadata

flowcept/flowceptor/consumers/agent/flowcept_agent_context_manager.py

@@ -1,145 +0,0 @@
-from dataclasses import dataclass
-from typing import Dict, List
-
-from flowcept.flowceptor.consumers.agent.base_agent_context_manager import BaseAgentContextManager, BaseAppContext
-from langchain.chains.retrieval_qa.base import BaseRetrievalQA
-from langchain_community.embeddings import HuggingFaceEmbeddings
-
-from flowcept.flowceptor.consumers.agent import client_agent
-from flowcept.flowceptor.consumers.agent.flowcept_qa_manager import FlowceptQAManager
-from flowcept.commons.task_data_preprocess import summarize_task
-
-
-@dataclass
-class FlowceptAppContext(BaseAppContext):
-    """
-    Context object for holding flowcept-specific state (e.g., tasks data) during the agent's lifecycle.
-
-    Attributes
-    ----------
-    task_summaries : List[Dict]
-        List of summarized task dictionaries.
-    critical_tasks : List[Dict]
-        List of critical task summaries with tags or anomalies.
-    qa_chain : BaseRetrievalQA
-        The QA chain used for question-answering over task summaries.
-    vectorstore_path : str
-        Path to the persisted vectorstore used by the QA system.
-    embedding_model : HuggingFaceEmbeddings
-        The embedding model used to generate vector representations for tasks.
-    """
-
-    task_summaries: List[Dict]
-    critical_tasks: List[Dict]
-    qa_chain: BaseRetrievalQA
-    vectorstore_path: str
-    embedding_model: HuggingFaceEmbeddings
-
-
-class FlowceptAgentContextManager(BaseAgentContextManager):
-    """
-    Manages agent context and operations for Flowcept's intelligent task monitoring.
-
-    This class extends BaseAgentContextManager and maintains a rolling buffer of task messages.
-    It summarizes and tags tasks, builds a QA index over them, and uses LLM tools to analyze
-    task batches periodically.
-
-    Attributes
-    ----------
-    context : FlowceptAppContext
-        Current application context holding task state and QA components.
-    msgs_counter : int
-        Counter tracking how many task messages have been processed.
-    context_size : int
-        Number of task messages to collect before triggering QA index building and LLM analysis.
-    qa_manager : FlowceptQAManager
-        Utility for constructing QA chains from task summaries.
-    """
-
-    def __init__(self):
-        super().__init__()
-        self.context: FlowceptAppContext = None
-        self.reset_context()
-        self.msgs_counter = 0
-        self.context_size = 5
-        self.qa_manager = FlowceptQAManager()
-
-    def message_handler(self, msg_obj: Dict):
-        """
-        Handle an incoming message and update context accordingly.
-
-        Parameters
-        ----------
-        msg_obj : Dict
-            The incoming message object.
-
-        Returns
-        -------
-        bool
-            True if the message was handled successfully.
-        """
-        msg_type = msg_obj.get("type", None)
-        if msg_type == "task":
-            self.msgs_counter += 1
-            self.logger.debug("Received task msg!")
-            self.context.tasks.append(msg_obj)
-
-            self.logger.debug(f"This is QA! {self.context.qa_chain}")
-
-            task_summary = summarize_task(msg_obj)
-            self.context.task_summaries.append(task_summary)
-            if len(task_summary.get("tags", [])):
-                self.context.critical_tasks.append(task_summary)
-
-            if self.msgs_counter > 0 and self.msgs_counter % self.context_size == 0:
-                self.build_qa_index()
-
-                self.monitor_chunk()
-
-        return True
-
-    def monitor_chunk(self):
-        """
-        Perform LLM-based analysis on the current chunk of task messages and send the results.
-        """
-        self.logger.debug(f"Going to begin LLM job! {self.msgs_counter}")
-        result = client_agent.run_tool("analyze_task_chunk")
-        if len(result):
-            content = result[0].text
-            if content != "Error executing tool":
-                msg = {"type": "flowcept_agent", "info": "monitor", "content": content}
-                self._mq_dao.send_message(msg)
-                self.logger.debug(str(content))
-            else:
-                self.logger.error(content)
-
-    def build_qa_index(self):
-        """
-        Build a new QA index from the current list of task summaries.
-        """
-        self.logger.debug(f"Going to begin QA Build! {self.msgs_counter}")
-        try:
-            qa_chain_result = self.qa_manager.build_qa(docs=self.context.task_summaries)
-
-            self.context.qa_chain = qa_chain_result.get("qa_chain")
-            self.context.vectorstore_path = qa_chain_result.get("path")
-
-            self.logger.debug(f"Built QA! {self.msgs_counter}")
-            assert self.context.qa_chain is not None
-            self.logger.debug(f"This is QA! {self.context.qa_chain}")
-            self.logger.debug(f"This is QA path! {self.context.vectorstore_path}")
-        except Exception as e:
-            self.logger.exception(e)
-
-    def reset_context(self):
-        """
-        Reset the agent's context to a clean state, initializing a new QA setup.
-        """
-        self.context = FlowceptAppContext(
-            tasks=[],
-            task_summaries=[],
-            critical_tasks=[],
-            qa_chain=None,
-            vectorstore_path=None,
-            embedding_model=FlowceptQAManager.embedding_model,
-        )