<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Steve Haertel on Medium]]></title>
        <description><![CDATA[Stories by Steve Haertel on Medium]]></description>
        <link>https://medium.com/@stevehaertel?source=rss-44c7ad711427------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*fzonGJ_jKCfFofe91gmplQ.jpeg</url>
            <title>Stories by Steve Haertel on Medium</title>
            <link>https://medium.com/@stevehaertel?source=rss-44c7ad711427------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 08:19:28 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@stevehaertel/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Bringing Transparency to Multi-Agent Workflows: Real-Time Chat Feedback in Langflow]]></title>
            <link>https://medium.com/@stevehaertel/bringing-transparency-to-multi-agent-workflows-real-time-chat-feedback-in-langflow-99ddd7b278e1?source=rss-44c7ad711427------2</link>
            <guid isPermaLink="false">https://medium.com/p/99ddd7b278e1</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[agentic-workflow]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[langflow]]></category>
            <category><![CDATA[ai-agents-in-action]]></category>
            <dc:creator><![CDATA[Steve Haertel]]></dc:creator>
            <pubDate>Mon, 13 Apr 2026 15:32:15 GMT</pubDate>
            <atom:updated>2026-04-13T15:32:15.430Z</atom:updated>
            <content:encoded><![CDATA[<p>If you’ve been building LLM agents lately, you’ve probably noticed something: agents work better together. This has been highlighted in <a href="https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/">Agent-to-Agent (A2A) interoperability announcements</a>, emphasizing that the future of AI isn’t just about individual agents, it’s about orchestrating multiple specialized agents to tackle complex tasks.</p><p>But here’s the catch: when your user asks a question and multiple agents spring into action behind the scenes, <strong>what do they see?</strong></p><p>Usually… nothing. Just a loading spinner. Then suddenly: 🥳 Surprise! 🥳A final answer appears. No context. No transparency. No idea what just happened.</p><p>That’s a problem. And it’s one I set out to solve with a set of custom Langflow components that bring real-time progress updates to multi-agent workflows.</p><h3>The Problem: The Black Box Effect</h3><p>By default, Langflow has a visibility gap when working with multi-agent flows:</p><ul><li><strong>Only the final agent’s output shows up</strong> in the chat and intermediate agents work in silence</li><li><strong>No native progress updates</strong> during long-running flows</li><li><strong>No way to update chat content</strong> dynamically as the flow progresses</li></ul><p>Imagine asking an agent to analyze a contract. Behind the scenes, Agent 1 parses the document, Agent 2 validates clauses, and Agent 3 generates a summary. Your user sees… <strong>nothing until Agent 3’s summary the very end.</strong> This UX leave much to be desired, and it’s difficult to assert that this builds trust.</p><h3>The Solution: Custom Components for Real-Time Feedback</h3><p>I’ve developed a set of custom Langflow components that solve this transparency problem. You can check out the implementation in my <a href="https://github.com/stevehaertel/langflow/tree/proposal/real-time-progress-updates-multi-agent/src/lfx/src/lfx/components/realtimeupdates">proposal branch on GitHub</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cnhiCbPC0wuApDkbqY_0fQ.jpeg" /><figcaption>An example flow (which you can download at the bottom of this blog!) to show the new components in action</figcaption></figure><p>Here’s what these components do:</p><p><strong>1. Shared Progress Manager</strong></p><p>Think of this as the “message bus” for your flow. It’s a shared object that gets passed around to wherever progress updates need to happen. All the components that want to report progress tap into this manager.</p><p><strong>2. Progress Update Injector</strong></p><p>This is where the magic happens. Whenever an agent or component wants to tell the user what’s going on, it uses the injector to push updates directly into the chat <strong>while the flow is still running</strong>. No more waiting until the end.</p><p><strong>3. Progress Finalizer</strong></p><p>When a block of work completes, this component marks it as done. Clean, simple, and it keeps your chat organized.</p><p><strong>4. Agent-with-Progress</strong></p><p>This is a wrapper around Langflow’s default agent component. It lets agents contribute their tool calls and updates to the chat in real-time. The key here? I made sure it stores messages and tool calls <strong>exactly the same way</strong> as normal agents, so subsequent agents in your chain can still access the full context history. No breaking changes to your workflow logic.</p><h3>What You Get: Transparency in Action</h3><p>With these components in place, here’s what your users experience:</p><ul><li><strong>First agent’s tool calls appear immediately</strong> in the chat, even if that Agent 1’s final output isn’t meant for the user -&gt; You still get to see what it’s doing</li><li><strong>Progress updates from non-agent components</strong> show up as the flow runs (e.g., “Parsing request…”, “Validating contract…”)</li><li><strong>In-place updates</strong> where later progress messages can overwrite earlier ones (e.g., “Validating contract… ✓ Complete”)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/789/1*nGa2HgEgej-3s1tXAli0Eg.jpeg" /><figcaption>A question answered by agent 1 shows its tool calls in the chat (Not possible at this time without these custom components)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/815/1*BGF4XNmnLKJ7ae9mDPH8yA.jpeg" /><figcaption>A question answered by agent 2 still shows the “progress updates” along the way before the final answer (Also not possible at this time without these custom components)</figcaption></figure><p>Here’s a quick example flow structure:</p><pre>User Input → Agent 1 (with progress) → Progress Update → Agent 2 (with progress) → Final Output<br>              ↓                          ↓                  ↓<br>         &quot;Calling tool X&quot;          &quot;Parsing request&quot;   &quot;Calling tool Y&quot;</pre><p>Every step reports back to the user. Full transparency.</p><h3>Why This Matters</h3><p><strong>Trust through transparency.</strong> When users can see what’s happening, they trust the system more. They understand that work is being done, even if it takes a few seconds.</p><p><strong>Better debugging.</strong> As a developer, seeing real-time updates helps you understand where flows slow down or fail. It’s invaluable for optimization.</p><p><strong>Improved UX.</strong> Nobody likes staring at a blank screen. Progress updates keep users engaged and informed.</p><h3>A Solution for Enhancing Existing Functionality</h3><p>Let me be clear: this is a workaround. Ideally, Langflow would support this natively without requiring you to pass around a progress manager object or use custom components (<a href="https://github.com/langflow-ai/langflow/issues/12259">Enhancement suggested!</a>). The current implementation has some quirks:</p><ul><li>You need to manually wire the progress manager through your flow</li><li>Progress updates currently show up with a hardcoded “Called tool” label in the UI (though this could be customized with a small frontend tweak)</li></ul><p>But until Langflow builds this functionality into the core platform, these custom components get the job done, and they get it done well if I do say so myself!</p><h3>Try It Yourself</h3><p>Want to implement real-time progress updates in your own flows? Here’s what you need:</p><ol><li><strong>Grab the custom components</strong> from my <a href="https://github.com/stevehaertel/langflow/tree/proposal/real-time-progress-updates-multi-agent/src/lfx/src/lfx/components/realtimeupdates">GitHub branch</a></li><li><strong>Import the demo flow</strong> (<a href="https://github.com/user-attachments/files/26144206/Progress.update.demo.json">download here</a>)</li><li><strong>Wire up the progress manager</strong> to your agents and update points</li><li><strong>Test it out</strong> with these example questions:</li></ol><ul><li>Ask: <em>“</em><strong><em>What is the metadata about my data product with id ABC?”</em></strong> — This will trigger the first agent to answer the question directly</li><li>Ask: <em>“</em><strong><em>What is the data in my data product with id ABC?”</em></strong> — This will engage the full multi-agent flow, showcasing all the real-time chat update features as the second agent kicks in</li></ul><p>Watch as progress updates appear in real-time, showing you exactly what each agent is doing behind the scenes. 🎉</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=99ddd7b278e1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building a Smart Data Assistant: Consuming IBM Data Product Hub Data with Langflow]]></title>
            <link>https://medium.com/@stevehaertel/building-a-smart-data-assistant-consuming-ibm-data-product-hub-data-with-langflow-1195adecfc80?source=rss-44c7ad711427------2</link>
            <guid isPermaLink="false">https://medium.com/p/1195adecfc80</guid>
            <dc:creator><![CDATA[Steve Haertel]]></dc:creator>
            <pubDate>Tue, 04 Nov 2025 20:26:55 GMT</pubDate>
            <atom:updated>2025-11-13T15:35:22.522Z</atom:updated>
            <content:encoded><![CDATA[<p>Hey there! So you’ve got data sitting in IBM Data Product Hub, and you’re wondering how to make it actually useful without writing a ton of custom code? Well, I’ve got good news for you. Today, we’re going to build an intelligent agent using Langflow that can chat with your data like it’s having a conversation with a colleague.</p><p>Think of it this way: instead of writing SQL queries or wrestling with APIs every time someone asks <em>“What’s in our dataset?”</em> or <em>“Show me records where X equals Y,”</em> you’ll have an AI agent that understands natural language and does the heavy lifting for you. Pretty cool, right?</p><h3><strong>What We’re Building</strong></h3><p>By the end of this guide, you’ll have a Langflow agent that can:</p><ul><li>Retrieve details about your subscribed data products from IBM Data Product Hub</li><li>Pull the actual data using Apache Arrow Flight (don’t worry, we’ll handle the complexity)</li><li>Answer questions about your data in plain English</li><li>Filter and analyze data on the fly</li></ul><p>Whether you’re a data engineer looking to streamline your workflow or a business analyst who wants to empower your team with self-service data access, this guide has you covered.</p><h3><strong>Before We Start</strong></h3><p>Let’s make sure you’ve got everything you need:</p><p><strong>Required:</strong></p><ul><li>An instance of IBM Data Product Hub (obviously!)</li><li>A data product subscription with assets delivered via the Flight service</li><li>An IBM Cloud API key</li><li>An API key for a Language Model</li><li>(If you’re using watsonx.ai for your language model) A watsonx.ai Runtime instance associated with a project. (The association can be made in the project settings)</li><li>About 30 minutes of your time</li></ul><p><strong>Nice to Have:</strong></p><ul><li>Basic familiarity with Python virtual environments</li><li>A cup of coffee ☕ (optional but recommended)</li></ul><h3><strong>Setting Up Your Environment</strong></h3><p>Alright, let’s get our hands dirty. First, we need to create a clean Python environment for Langflow.</p><p><strong>Step 1: Create a Virtual Environment</strong></p><p>Open your terminal and run:</p><pre>python3 -m venv $HOME/langflow-blog</pre><p>This creates an isolated environment so we don’t mess with your other Python projects. Good practice, trust me.</p><p><strong>Step 2: Activate the Environment</strong></p><pre>source $HOME/langflow-blog/bin/activate</pre><p>You should see `(langflow-blog)` appear in your terminal prompt. That means you’re in!</p><p><strong>Step 3: Install Langflow</strong></p><p>Now for the fun part. We’ll use `uv` (a fast Python package installer) to get Langflow:</p><pre>uv pip install langflow -U</pre><p>Grab that coffee while this installs. It’ll take a minute or two.</p><p><strong>Step 4: Configure Your Environment Variables</strong></p><p>Create a `.env` file to store your IBM Cloud credentials:</p><pre>touch $HOME/langflow-blog/.env</pre><p>Now open that file in your favorite editor and add these variables:</p><pre>DPH_CATALOG_ID=&#39;[YOUR_DPH_CATALOG_ID]&#39;<br>CLOUD_API_HOSTNAME=&#39;api.dataplatform.cloud.ibm.com&#39;<br>CLOUD_IAM_HOSTNAME=&#39;iam.cloud.ibm.com&#39;<br>CLOUD_API_KEY=&#39;[YOUR_IBM_CLOUD_API_KEY]&#39;</pre><p><strong>Note:</strong> To find your catalog through the UI, open up your browser’s developer console and type `dphDefaultCatalog`. It will be in GUID format.</p><p><strong>Pro tip:</strong> Replace the bracketed values with your actual credentials. You can find your catalog ID in the Data Product Hub UI, and you can create an API key in your IBM Cloud account settings.</p><p><strong>Step 5: Fire Up Langflow</strong></p><p>Ready to see begin? Start Langflow with:</p><pre>uv run langflow run --env-file $HOME/langflow-blog/.env</pre><p>Langflow will start up and give you a URL (usually `http://localhost:7860`). Open that in your browser, and you’ll see the Langflow UI. Welcome to the party! 🎉</p><h3><strong>Building Your First Flow</strong></h3><p>Now comes the fun part: building your agent flow. Think of a flow as a visual pipeline where data and AI components work together.</p><p><strong>Create a Blank Flow</strong></p><p>When you first open Langflow, you’ll see a <strong>“Create first flow”</strong> button. Click it and select “<strong>Blank Flow”</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/210/1*uWhwJxEzSq5crPEiVLempg.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/160/1*9mAWD8suIEbjU5625vYssA.jpeg" /></figure><p>You’ll be greeted with a clean canvas. This is where we’ll build our data assistant.</p><p><strong>Set Up Global Variables</strong></p><p>Before we start adding components, let’s configure some global variables that our flow will use.</p><ol><li>Click on the <strong>Settings</strong> icon (looks like a gear) in the top right</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/287/1*3IP46bp-2LbozLqfZnO7cw.jpeg" /></figure><p>2. Navigate to <strong>Global Variables</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/243/1*Prs4dM5xrwtLAYKngksvrg.jpeg" /></figure><p>Add these two variables:</p><p><strong>`WX_AI_CONTAINER_ID`</strong>: This is your Watsonx AI project ID. You can find it at <a href="https://dataplatform.dev.cloud.ibm.com/wx/home?context=wx">https://dataplatform.cloud.ibm.com/wx/home?context=wx</a></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/303/1*XGr3hy4skx2s36nzZA72IA.jpeg" /></figure><p><strong>`WX_API_KEY`</strong>: Set this as a credential (use the lock icon). This is your IBM Cloud API key.</p><p>These variables will be available throughout your flow, making it easy to manage credentials securely.</p><h3><strong>Adding the Core Components</strong></h3><p>Now let’s build the brain of our operation. We need three main pieces: an Agent, a Language Model, and Chat interfaces.</p><p><strong>Add the Agent Component</strong></p><p>1. In the left sidebar, search for “<strong>Agent”</strong></p><p>2. Double-click the <strong>Agent</strong> component to add it to your canvas</p><p>The Agent is the orchestrator. It decides which tools to use and how to respond to user queries.</p><p><strong>Add Your Language Model</strong></p><p>If you’re using IBM Watsonx.ai (which I recommend for this use case):</p><p>1. Search for “<strong>watsonx”</strong> in the components search bar</p><p>2. Double-click “<strong>IBM watsonx.ai”</strong> to add it</p><p>3. In the watsonx component, set the output type to “<strong>Language Model”</strong> (you’ll find this at the bottom of the component)</p><p>4. In the Agent component, set the Language Model field to “<strong>Connect other models”</strong></p><p>5. Draw a connection from the watsonx output to the Agent’s Language Model input</p><p><strong>Using a different LLM?</strong> No problem! If you’re using OpenAI, Anthropic, or another provider that’s in the Agent’s default dropdown, just select it directly.</p><p>Don’t forget to add your environment variables to these components by clicking the globe icon (🌐) next to the relevant fields.</p><p><strong>Configure Agent Instructions</strong></p><p>Click on the “<strong>Agent Instructions”</strong> field in your Agent component. This is where you tell your agent how to behave. Here’s a good starting point:</p><pre>You are a helpful data assistant that helps users explore and analyze data from IBM Data Product Hub.<br>When users ask about data, use the available tools to retrieve information and provide clear, concise answers.<br>Always explain what you&#39;re doing and ask for clarification if needed.<br>When referencing column names, use human friendly words.</pre><p>Feel free to refine this over time based on how your agent performs.</p><p>Your flow should now look something like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/939/1*Ob9ST38dJqnHZo9PdlD1AQ.jpeg" /></figure><p><strong>Add Chat Input and Output</strong></p><p>An agent isn’t much use if users can’t talk to it! Let’s add chat interfaces:</p><p>1. Search for “<strong>Chat”</strong> in the components</p><p>2. Add “<strong>Chat Input”</strong> and “<strong>Chat Output”</strong> to your canvas</p><p>3. Connect Chat Input to the Agent’s <strong>Input</strong> port</p><p>4. Connect the Agent’s <strong>Output</strong> port to Chat Output</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/961/1*yeK606hdEp2tFBiJ45PhIw.jpeg" /></figure><p>Now you’ve got a basic conversational flow! But we need to give our agent some tools to work with.</p><h3><strong>Adding Out-of-the-Box Tools</strong></h3><p>Let’s start simple by adding a couple of built-in tools so you can see how the agent uses them.</p><p>Search for and add these components:</p><ul><li><strong>Calculator —&gt; </strong>for doing math</li><li><strong>Current Date</strong> → for date/time queries</li></ul><p>For both components:</p><p>1. Toggle “<strong>Tool Mode”</strong> to ON</p><p>2. Connect them to the Agent’s <strong>Tools</strong> input</p><p>Now test your flow! Click the <strong>Playground</strong> button in the top right corner and ask: <em>“What day is today?”</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/838/1*7UHhB98eU3t4aoju4Jo7ZQ.jpeg" /></figure><p>You should see the agent use the Current Date tool to answer. Pretty neat, right? This shows that the agent knows how to pick the right tool for the job.</p><h3><strong>The Real Magic: Custom Data Tools</strong></h3><p>Okay, here’s where things get interesting. We’re going to create two custom components that let your agent interact with IBM Data Product Hub data.</p><p><strong>Custom Component #1: Get Data Descriptors</strong></p><p>This component retrieves information about your subscribed data products. Basically, it tells the agent what data is available.</p><p>1. Click “<strong>New Custom Component”</strong> in the lower left corner</p><p>2. Add it to your flow and toggle <strong>Tool Mode</strong> ON</p><p>3. Click the “<strong>Code”</strong> button at the top of the component</p><p>4. Replace the code with the following:</p><pre>&quot;&quot;&quot;<br>Langflow component for retrieving data product subscription delivery details.<br><br>This module provides a component that interfaces with IBM Cloud Data Product Hub<br>to fetch flight descriptors for subscribed data assets.<br>&quot;&quot;&quot;<br><br>import json<br>import os<br>from enum import Enum<br>from typing import Any, Dict, Optional<br><br>import pandas as pd<br>import requests<br>from loguru import logger<br><br>from langflow.custom.custom_component.component import Component<br>from langflow.io import MessageTextInput, Output<br>from langflow.schema.data import Data<br><br>class HttpClient:<br>    &quot;&quot;&quot;<br>    A common HTTP client for making API requests.<br>    <br>    This client provides a simplified interface for HTTP operations<br>    with consistent error handling and configuration.<br>    &quot;&quot;&quot;<br><br>    def get(<br>        self,<br>        url: str,<br>        params: Optional[Dict[str, Any]] = None,<br>        headers: Optional[Dict[str, str]] = None,<br>        timeout: int = 60,<br>        **kwargs<br>    ) -&gt; requests.Response:<br>        &quot;&quot;&quot;<br>        Send a GET request.<br><br>        Args:<br>            url: URL for the request<br>            params: Query parameters to append to the URL<br>            headers: Request headers<br>            timeout: Request timeout in seconds (default: 60)<br>            **kwargs: Additional arguments to pass to requests.get<br><br>        Returns:<br>            requests.Response: The response object<br><br>        Note:<br>            SSL verification is disabled (verify=False) for development/testing.<br>            This should be enabled in production environments.<br>        &quot;&quot;&quot;<br>        return requests.get(<br>            url,<br>            params=params,<br>            headers=headers,<br>            timeout=timeout,<br>            verify=False,  # WARNING: SSL verification disabled - enable in production<br>            **kwargs<br>        )<br><br><br>class HTTPMethod(Enum):<br>    &quot;&quot;&quot;HTTP method enumeration for API requests.&quot;&quot;&quot;<br>    <br>    GET = &quot;GET&quot;<br>    POST = &quot;POST&quot;<br>    PATCH = &quot;PATCH&quot;<br>    PUT = &quot;PUT&quot;<br>    DELETE = &quot;DELETE&quot;<br><br><br>class GetDataDescriptorsComponent(Component):<br>    &quot;&quot;&quot;<br>    Langflow component for retrieving data product subscription delivery details.<br>    <br>    This component connects to IBM Cloud Data Product Hub to fetch flight descriptors<br>    for subscribed data assets. It handles authentication, API requests, and data<br>    transformation to provide structured information about delivered data products.<br>    &quot;&quot;&quot;<br>    <br>    display_name = &quot;Get Data Descriptors Component&quot;<br>    description = &quot;Retrieve flight descriptor for a data set&quot;<br>    documentation: str = &quot;https://docs.langflow.org/components-custom-components&quot;<br>    icon = &quot;code&quot;<br>    name = &quot;GetDataDescriptorsComponent&quot;<br><br>    inputs = [<br>        MessageTextInput(<br>            name=&quot;data_product_subscription_id&quot;,<br>            display_name=&quot;Data Product Subscription ID&quot;,<br>            info=&quot;The id of the data product subscription for which to get the delivered flight descriptors&quot;,<br>            tool_mode=True,<br>        )<br>    ]<br><br>    outputs = [<br>        Output(<br>            display_name=&quot;Data Details&quot;,<br>            name=&quot;data_product_subscription_delivery_details&quot;,<br>            method=&quot;get_delivered_data_details&quot;<br>        ),<br>    ]<br><br>    @staticmethod<br>    def create_default_headers(<br>        content_type: str = &quot;application/json&quot;,<br>        accept_type: str = &quot;application/json&quot;,<br>        additional_headers: Optional[Dict[str, str]] = None,<br>    ) -&gt; Dict[str, str]:<br>        &quot;&quot;&quot;<br>        Create default headers for API requests.<br><br>        Args:<br>            content_type: Content type for the request (default: application/json)<br>            accept_type: Accept type for the request (default: application/json)<br>            additional_headers: Additional headers to include in the request<br><br>        Returns:<br>            Dict[str, str]: Complete headers dictionary for the request<br>        &quot;&quot;&quot;<br>        headers = {<br>            &quot;Content-Type&quot;: content_type,<br>            &quot;accept&quot;: accept_type<br>        }<br><br>        if additional_headers:<br>            headers.update(additional_headers)<br><br>        return headers<br><br>    def get_bearer_token(self) -&gt; str:<br>        &quot;&quot;&quot;<br>        Authenticate with IBM Cloud IAM and retrieve a bearer token.<br><br>        This method uses the Cloud API key to obtain an OAuth access token<br>        from IBM Cloud Identity and Access Management (IAM).<br><br>        Returns:<br>            str: Bearer token string formatted as &quot;Bearer &lt;access_token&gt;&quot;<br><br>        Raises:<br>            Exception: If authentication fails or environment variables are not set<br><br>        Environment Variables Required:<br>            CLOUD_API_KEY: IBM Cloud API key for authentication<br>            CLOUD_IAM_HOSTNAME: IBM Cloud IAM hostname (e.g., iam.cloud.ibm.com)<br>        &quot;&quot;&quot;<br>        cloud_api_key = os.getenv(&quot;CLOUD_API_KEY&quot;)<br>        cloud_iam_hostname = os.getenv(&quot;CLOUD_IAM_HOSTNAME&quot;)<br><br>        if not cloud_api_key or not cloud_iam_hostname:<br>            raise ValueError(<br>                &quot;Missing required environment variables: CLOUD_API_KEY and/or CLOUD_IAM_HOSTNAME&quot;<br>            )<br><br>        logger.info(&quot;Authenticating with Data Product Hub&quot;)<br><br>        # Request OAuth token from IBM Cloud IAM<br>        iam_url = f&quot;https://{cloud_iam_hostname}/identity/token&quot;<br>        payload = {<br>            &quot;grant_type&quot;: &quot;urn:ibm:params:oauth:grant-type:apikey&quot;,<br>            &quot;apikey&quot;: cloud_api_key<br>        }<br><br>        response = requests.post(iam_url, data=payload).json()<br>        token = f&quot;Bearer {response[&#39;access_token&#39;]}&quot;<br><br>        return token<br><br>    def execute_get_request(<br>        self,<br>        url: str,<br>        headers: Optional[Dict[str, str]] = None,<br>        params: Optional[Dict[str, Any]] = None,<br>        tool_name: Optional[str] = None,<br>    ) -&gt; Dict[str, Any]:<br>        &quot;&quot;&quot;<br>        Execute a GET request with authorization and error handling.<br><br>        This method adds the bearer token to headers, executes the request,<br>        and handles common error patterns.<br><br>        Args:<br>            url: URL for the request<br>            headers: Headers for the request (default headers will be created if None)<br>            params: Query parameters for the request<br>            tool_name: Name of the tool making the request (used in error messages)<br><br>        Returns:<br>            Dict[str, Any]: JSON response from the API<br><br>        Raises:<br>            TypeError: If the request fails or returns an error status code<br>        &quot;&quot;&quot;<br>        # Use default headers if none provided<br>        if headers is None:<br>            headers = self.create_default_headers()<br><br>        # Add authorization token to headers<br>        headers[&quot;Authorization&quot;] = self.get_bearer_token()<br><br>        try:<br>            http_client = HttpClient()<br>            response = http_client.get(url=url, headers=headers, params=params)<br><br>            return self._handle_response(response, HTTPMethod.GET, tool_name)<br><br>        except Exception as e:<br>            error_message = f&quot;{tool_name or &#39;Request&#39;} to {url} failed with error: {str(e)}&quot;<br>            logger.error(error_message)<br>            self.status = error_message<br>            raise TypeError(error_message)<br><br>    def _handle_response(<br>        self,<br>        response: requests.Response,<br>        method: HTTPMethod,<br>        tool_name: Optional[str] = None,<br>    ) -&gt; Dict[str, Any]:<br>        &quot;&quot;&quot;<br>        Handle API response and check for errors.<br><br>        Args:<br>            response: Response object from requests library<br>            method: HTTP method used for the request<br>            tool_name: Name of the tool making the request (used in error messages)<br><br>        Returns:<br>            Dict[str, Any]: JSON response if successful<br><br>        Raises:<br>            TypeError: If the response status code indicates an error<br>        &quot;&quot;&quot;<br>        # Success: 2xx status codes<br>        if 200 &lt;= response.status_code &lt; 300:<br>            return response.json()<br><br>        # Not Found: 404 status code<br>        elif response.status_code == 404 and method == HTTPMethod.GET:<br>            error_message = (<br>                f&quot;Tool {tool_name or &#39;request&#39;} call finishes unsuccessfully &quot;<br>                f&quot;because resource not found. Status code: &#39;{response.status_code}&#39;&quot;<br>            )<br>            logger.error(f&quot;{error_message}, Response: {response.text}&quot;)<br>            self.status = error_message<br>            raise TypeError(error_message)<br><br>        # Other errors<br>        else:<br>            error_message = (<br>                f&quot;Tool {tool_name or &#39;request&#39;} call finishes unsuccessfully. &quot;<br>                f&quot;Status code: &#39;{response.status_code}&#39;&quot;<br>            )<br>            logger.error(f&quot;{error_message}, Response: {response.text}&quot;)<br>            self.status = error_message<br>            raise TypeError(error_message)<br><br>    def get_delivered_data_details(self) -&gt; Data:<br>        &quot;&quot;&quot;<br>        Retrieve delivery details for a data product subscription.<br><br>        This method fetches information about all data assets associated with<br>        a subscription, including their names and flight asset IDs.<br><br>        Returns:<br>            Data: Langflow Data object containing subscription delivery details<br><br>        Raises:<br>            TypeError: If the API request fails or data retrieval encounters an error<br><br>        Environment Variables Required:<br>            DPH_CATALOG_ID: Data Product Hub catalog ID<br>            CLOUD_API_HOSTNAME: IBM Cloud API hostname<br>        &quot;&quot;&quot;<br>        catalog_id = os.getenv(&quot;DPH_CATALOG_ID&quot;)<br>        cloud_api_hostname = os.getenv(&quot;CLOUD_API_HOSTNAME&quot;)<br><br>        if not catalog_id or not cloud_api_hostname:<br>            raise ValueError(<br>                &quot;Missing required environment variables: DPH_CATALOG_ID and/or CLOUD_API_HOSTNAME&quot;<br>            )<br><br>        logger.info(<br>            f&quot;Started getting details of subscription with id: {self.data_product_subscription_id}&quot;<br>        )<br><br>        try:<br>            # Prepare query parameters<br>            params = {&quot;catalog_id&quot;: catalog_id}<br><br>            # Get Data Product Subscription items<br>            subscription_url = (<br>                f&quot;https://{cloud_api_hostname}/v2/asset_lists/&quot;<br>                f&quot;{self.data_product_subscription_id}/items&quot;<br>            )<br>            subscription_response = self.execute_get_request(subscription_url)<br><br>            # Process each subscribed asset<br>            subscribed_product_assets = []<br>            items = subscription_response.get(&quot;items&quot;, [])<br><br>            for item in items:<br>                # Extract asset IDs from the subscription item<br>                data_asset_id = item.get(&quot;asset&quot;, {}).get(&quot;id&quot;)<br>                flight_asset_id = (<br>                    item.get(&quot;properties&quot;, {})<br>                    .get(&quot;assets_out&quot;, [{}])[0]<br>                    .get(&quot;asset_id&quot;)<br>                )<br><br>                # Fetch detailed metadata for the data asset<br>                data_asset_url = f&quot;https://{cloud_api_hostname}/v2/assets/{data_asset_id}&quot;<br>                data_asset_response = self.execute_get_request(<br>                    data_asset_url,<br>                    params=params<br>                )<br><br>                # Extract the asset name from metadata<br>                data_asset_name = data_asset_response.get(&quot;metadata&quot;, {}).get(&quot;name&quot;)<br><br>                # Build the subscribed asset metadata object<br>                subscribed_product_asset = {<br>                    &quot;name&quot;: data_asset_name,<br>                    &quot;flight_asset_id&quot;: flight_asset_id<br>                }<br>                subscribed_product_assets.append(subscribed_product_asset)<br><br>            # Log the retrieved assets for debugging<br>            logger.info(f&quot;Retrieved assets: {subscribed_product_assets}&quot;)<br><br>            # Create and return Langflow Data object<br>            data = Data(<br>                data_product_subscription_delivery_details=subscribed_product_assets<br>            )<br>            self.status = data<br>            return data<br><br>        except Exception as e:<br>            error_message = f&quot;Exception when getting delivered flight descriptors: {e!s}&quot;<br>            logger.error(error_message)<br>            self.status = error_message<br>            raise TypeError(error_message)</pre><p><strong>What does this do?</strong> This component takes a subscription ID and returns a list of all the data assets in that subscription, along with their Flight asset IDs. Think of it as a catalog lookup. It tells the agent what data is available to work with.</p><p><strong>Custom Component #2: Extract Data</strong></p><p>Now for the second component. This one actually pulls the data using Apache Arrow Flight.</p><p>1. Create another <strong>New Custom Component</strong></p><p>2. Toggle <strong>Tool Mode</strong> ON</p><p>3. Click <strong>Code</strong> and paste this:</p><pre>&quot;&quot;&quot;<br>Langflow component for extracting data from IBM Cloud Data Product Hub using Apache Arrow Flight.<br><br>This module provides a component that retrieves data using flight descriptors,<br>saves it to CSV files, and optionally filters the data using pandas query strings.<br>&quot;&quot;&quot;<br><br>import json<br>import os<br><br>import pandas as pd<br>import requests<br>from loguru import logger<br>from pyarrow import flight<br><br>from langflow.custom.custom_component.component import Component<br>from langflow.io import MessageTextInput, Output<br>from langflow.schema.data import Data<br>from langflow.schema.dataframe import DataFrame<br><br><br>class TokenClientAuthHandler(flight.ClientAuthHandler):<br>    &quot;&quot;&quot;<br>    Custom authentication handler for Apache Arrow Flight client.<br>    <br>    This handler manages bearer token authentication for Flight RPC calls,<br>    implementing the ClientAuthHandler interface required by PyArrow Flight.<br>    &quot;&quot;&quot;<br><br>    def __init__(self, token: str):<br>        &quot;&quot;&quot;<br>        Initialize the authentication handler with a bearer token.<br><br>        Args:<br>            token: Bearer token string for authentication<br>        &quot;&quot;&quot;<br>        super().__init__()<br>        str_token = str(token)<br>        self.token = str_token.encode(&#39;utf-8&#39;)<br><br>    def authenticate(self, outgoing, incoming):<br>        &quot;&quot;&quot;<br>        Perform the authentication handshake.<br><br>        Args:<br>            outgoing: Outgoing stream to write authentication data<br>            incoming: Incoming stream to read authentication response<br>        &quot;&quot;&quot;<br>        outgoing.write(self.token)<br>        self.token = incoming.read()<br><br>    def get_token(self) -&gt; bytes:<br>        &quot;&quot;&quot;<br>        Get the current authentication token.<br><br>        Returns:<br>            bytes: The current token as bytes<br>        &quot;&quot;&quot;<br>        return self.token<br><br><br>class ExtractDataComponent(Component):<br>    &quot;&quot;&quot;<br>    Langflow component for extracting and filtering data from IBM Cloud Data Product Hub.<br>    <br>    This component uses Apache Arrow Flight protocol to retrieve data from the Data Product Hub,<br>    saves it to a CSV file, and optionally applies pandas query filters. It implements caching<br>    to avoid redundant data extraction when the CSV file already exists.<br>    &quot;&quot;&quot;<br><br>    display_name = &quot;Extract Data Component&quot;<br>    description = &quot;Retrieve data using a flight descriptor and save the data to a csv&quot;<br>    documentation: str = &quot;https://docs.langflow.org/components-custom-components&quot;<br>    icon = &quot;code&quot;<br>    name = &quot;ExtractDataComponent&quot;<br><br>    # Load environment variables for IBM Cloud configuration<br>    catalog_id = os.getenv(&quot;DPH_CATALOG_ID&quot;)<br>    CLOUD_API_HOSTNAME = os.getenv(&quot;CLOUD_API_HOSTNAME&quot;)<br>    CLOUD_IAM_HOSTNAME = os.getenv(&quot;CLOUD_IAM_HOSTNAME&quot;)<br>    CLOUD_API_KEY = os.getenv(&quot;CLOUD_API_KEY&quot;)<br><br>    inputs = [<br>        MessageTextInput(<br>            name=&quot;flight_descriptor_asset_id&quot;,<br>            display_name=&quot;Flight asset ID&quot;,<br>            info=&quot;The asset id of the delivered flight descriptor to get data from&quot;,<br>            tool_mode=True,<br>        ),<br>        MessageTextInput(<br>            name=&quot;query_string&quot;,<br>            display_name=&quot;Query string&quot;,<br>            info=&quot;A pandas.DataFrame.query string to run on the dataframe, in order to filter it. It is a boolean query&quot;,<br>            tool_mode=True,<br>        ),<br>    ]<br><br>    outputs = [<br>        Output(<br>            display_name=&quot;Data File Output&quot;,<br>            name=&quot;data_output_file&quot;,<br>            method=&quot;get_data&quot;<br>        ),<br>    ]<br><br>    def read_dataframe_file(self, dataframe_filename: str) -&gt; DataFrame:<br>        &quot;&quot;&quot;<br>        Read a CSV file into a DataFrame and optionally apply a query filter.<br><br>        This method reads the CSV file, applies any specified query string filter,<br>        and stores the result in the component context for potential reuse.<br><br>        Args:<br>            dataframe_filename: Path to the CSV file to read<br><br>        Returns:<br>            DataFrame: Langflow DataFrame object containing the filtered data<br><br>        Raises:<br>            TypeError: If reading the file or applying the query fails<br>        &quot;&quot;&quot;<br>        logger.info(f&quot;Reading dataframe from file: {dataframe_filename}&quot;)<br>        <br>        try:<br>            # Read CSV file into pandas DataFrame<br>            df = pd.read_csv(dataframe_filename)<br>            logger.info(&quot;Finished reading data frame file&quot;)<br><br>            # Apply query filter if provided<br>            if self.query_string:<br>                logger.info(f&quot;Applying query string: {self.query_string}&quot;)<br>                df = df.query(self.query_string)<br>                logger.info(&quot;Finished applying query filter&quot;)<br><br>            # Store DataFrame in component context for potential reuse<br>            self.ctx[dataframe_filename] = df<br>            <br>            # Create Langflow DataFrame wrapper<br>            output_df = DataFrame(df)<br>            self.status = df<br>            <br>            return output_df<br><br>        except Exception as e:<br>            error_message = f&quot;Exception when reading dataframe file: {e!s}&quot;<br>            logger.error(error_message)<br>            self.status = error_message<br>            raise TypeError(error_message)<br><br>    def extract_to_file(self, dataframe_filename: str) -&gt; Data:<br>        &quot;&quot;&quot;<br>        Extract data from IBM Cloud Data Product Hub using Apache Arrow Flight.<br><br>        This method establishes a Flight connection, authenticates using IBM Cloud IAM,<br>        retrieves data in chunks, and saves it to a CSV file.<br><br>        Args:<br>            dataframe_filename: Path where the CSV file will be saved<br><br>        Returns:<br>            Data: Langflow Data object containing the output filename<br><br>        Raises:<br>            TypeError: If the Flight connection or data extraction fails<br><br>        Environment Variables Required:<br>            DPH_CATALOG_ID: Data Product Hub catalog ID<br>            CLOUD_API_HOSTNAME: IBM Cloud API hostname<br>            CLOUD_IAM_HOSTNAME: IBM Cloud IAM hostname for authentication<br>            CLOUD_API_KEY: IBM Cloud API key for authentication<br>        &quot;&quot;&quot;<br>        asset_id = self.flight_descriptor_asset_id<br>        <br>        logger.info(<br>            f&quot;Started getting flight data - Asset ID: {asset_id}, &quot;<br>            f&quot;Filename: {dataframe_filename}, Catalog ID: {self.catalog_id}&quot;<br>        )<br><br>        # Prepare flight descriptor with asset and catalog information<br>        descriptor = {<br>            &quot;asset_id&quot;: asset_id,<br>            &quot;catalog_id&quot;: self.catalog_id<br>        }<br><br>        # Configure Flight connection parameters<br>        hostname = self.CLOUD_API_HOSTNAME<br>        port = &#39;443&#39;<br>        flight_url = f&#39;grpc+tls://{hostname}:{port}&#39;<br><br>        try:<br>            # Initialize Flight client with TLS<br>            read_client = flight.FlightClient(<br>                flight_url,<br>                override_hostname=hostname,<br>                disable_server_verification=True  # WARNING: Disabled for dev/test<br>            )<br>            logger.info(&quot;Initialized Flight read client&quot;)<br><br>            # Authenticate with IBM Cloud IAM to get bearer token<br>            logger.info(&quot;Authenticating with Data Product Hub&quot;)<br>            iam_url = f&#39;https://{self.CLOUD_IAM_HOSTNAME}/identity/token&#39;<br>            iam_payload = {<br>                &#39;grant_type&#39;: &#39;urn:ibm:params:oauth:grant-type:apikey&#39;,<br>                &#39;apikey&#39;: self.CLOUD_API_KEY<br>            }<br>            <br>            response = requests.post(iam_url, data=iam_payload).json()<br>            token = f&quot;Bearer {response[&#39;access_token&#39;]}&quot;<br><br>            # Authenticate the Flight client with the bearer token<br>            auth_handler = TokenClientAuthHandler(token)<br>            read_client.authenticate(<br>                auth_handler,<br>                options=flight.FlightCallOptions(timeout=5.0)<br>            )<br><br>            # Get flight information using the descriptor<br>            logger.info(&quot;Retrieving flight information&quot;)<br>            flight_descriptor = flight.FlightDescriptor.for_command(<br>                json.dumps(descriptor)<br>            )<br>            flight_info = read_client.get_flight_info(flight_descriptor)<br><br>            # Read data from all endpoints (typically just one)<br>            logger.info(&quot;Reading data from flight endpoints&quot;)<br>            reader = None<br>            for endpoint in flight_info.endpoints:<br>                reader = read_client.do_get(endpoint.ticket)<br><br>            # Read data in chunks and concatenate into a single DataFrame<br>            dph_frame = pd.DataFrame()<br>            chunk_count = 0<br>            <br>            while True:<br>                try:<br>                    chunk_count += 1<br>                    logger.info(f&quot;Reading chunk {chunk_count}...&quot;)<br>                    <br>                    # Read next chunk from the stream<br>                    chunk = reader.read_chunk()<br>                    table = chunk.data<br>                    df = table.to_pandas()<br>                    <br>                    # Concatenate with existing data<br>                    dph_frame = pd.concat([dph_frame, df], ignore_index=True)<br>                    <br>                except StopIteration:<br>                    # All chunks have been read<br>                    logger.info(f&quot;Finished reading {chunk_count - 1} chunks&quot;)<br>                    break<br><br>            # Log DataFrame info for debugging<br>            logger.info(f&quot;Retrieved DataFrame shape: {dph_frame.shape}&quot;)<br>            logger.debug(f&quot;DataFrame preview:\n{dph_frame.head()}&quot;)<br><br>            # Save DataFrame to CSV file<br>            dph_frame.to_csv(dataframe_filename, index=False)<br>            logger.info(f&quot;Saved data to: {os.path.abspath(dataframe_filename)}&quot;)<br><br>            # Return Data object with filename<br>            data = Data(data={&quot;data_output_file&quot;: dataframe_filename})<br>            return data<br><br>        except Exception as e:<br>            error_message = f&quot;Exception when getting Flight data: {e!s}&quot;<br>            logger.error(error_message)<br>            self.status = error_message<br>            raise TypeError(error_message)<br><br>    def get_data(self) -&gt; DataFrame:<br>        &quot;&quot;&quot;<br>        Main method to retrieve and process data.<br><br>        This method implements a caching strategy: if the CSV file already exists,<br>        it reads from the file. Otherwise, it extracts data from the Flight service<br>        and then reads the newly created file.<br><br>        Returns:<br>            DataFrame: Langflow DataFrame object containing the processed data<br><br>        Raises:<br>            TypeError: If data extraction or reading fails<br>        &quot;&quot;&quot;<br>        # Generate filename based on flight descriptor asset ID<br>        dataframe_filename = f&quot;{self.flight_descriptor_asset_id}.csv&quot;<br><br>        # Check if data has already been extracted<br>        if os.path.exists(dataframe_filename):<br>            logger.info(<br>                f&quot;Using previously extracted data from: {dataframe_filename}&quot;<br>            )<br>            return self.read_dataframe_file(dataframe_filename)<br>        else:<br>            logger.info(&quot;Extracting data through Flight protocol&quot;)<br>            <br>            # Extract data from Flight service<br>            self.extract_to_file(dataframe_filename)<br>            logger.info(&quot;Data extraction complete&quot;)<br>            <br>            # Read and return the extracted data<br>            return self.read_dataframe_file(dataframe_filename)</pre><p><strong>What does this do?</strong> This component takes a Flight asset ID and pulls the actual data using Apache Arrow Flight protocol. It saves the data to a CSV file (for caching) and can optionally filter it using pandas query strings. The cool part? It handles all the authentication and chunked data reading automatically.</p><p><strong>Connect Everything</strong></p><p>Now connect both custom components to your Agent’s <strong>Tools</strong> input. Your complete flow should look like this:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SYkRn26jZ_9krzwERLc5cg.jpeg" /></figure><p>You’ve now got:</p><ul><li>An agent with a language model</li><li>Chat interfaces for user interaction</li><li>Built-in tools (calculator, date)</li><li>Custom tools for Data Product Hub integration</li></ul><h3><strong>Taking It for a Test Drive</strong></h3><p>Time for the moment of truth! Click the <strong>Playground</strong> button and let’s see what this baby can do.</p><p><strong>Query 1: Get Subscription Details</strong></p><p>Start by asking about your data product subscription:</p><pre>What data assets are available in my subscription with ID [your-subscription-id]?</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/808/1*pO7GW4POpofc6lzMRilB_Q.jpeg" /></figure><p>The agent will use the Get Data Descriptors tool to fetch the details and tell you what’s available. Pretty slick!</p><p><strong>Query 2: Analyze the Data</strong></p><p>Now that the agent knows what data exists, you can ask it to analyze it:</p><pre>Can you get the data from the [asset-name] asset and tell me how many records there are?</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/803/1*DNRefK3rNNWHkDQqggu8HA.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/749/1*TmTVt0LnedS_Zt30XSdYxw.jpeg" /></figure><p>The agent will:</p><p>1. Use the Extract Data tool to pull the data via Flight</p><p>2. Save it to a CSV file</p><p>3. Read and analyze it</p><p>4. Give you the answer in plain English</p><p>You can even ask follow-up questions like:</p><p>- <em>“Show me records where column X is greater than 100”</em></p><p>- <em>“What’s the average value of column Y?”</em></p><p>- <em>“Filter the data to only show records from last month”</em></p><p>The agent will use pandas queries behind the scenes to filter and analyze the data on the fly.</p><p><strong>What You’ve Accomplished</strong></p><p>Let’s take a step back and appreciate what you’ve built here:</p><p>✅ <strong>Self-Service Data Access</strong>: Business users can now ask questions in natural language instead of writing SQL or calling APIs</p><p>✅ <strong>Intelligent Tool Selection</strong>: The agent automatically picks the right tool for each task, whether it’s getting metadata, extracting data, or doing calculations</p><p>✅ <strong>Secure Authentication</strong>: All IBM Cloud authentication is handled automatically using your API keys</p><p>✅ <strong>Efficient Data Handling</strong>: Data is cached locally after the first extraction, so subsequent queries are lightning fast</p><p>✅ <strong>Flexible Querying</strong>: Users can filter and analyze data using natural language, and the agent translates that into pandas queries</p><h3><strong>Next Steps and Ideas</strong></h3><p>Now that you’ve got the basics working, here are some ways to level up:</p><p><strong>Add More Tools</strong>: Create custom components for other data sources or APIs your team uses</p><p><strong>Enhance the Agent Instructions</strong>: Fine-tune how the agent responds based on your team’s needs</p><p><strong>Add Data Visualization</strong>: Create a tool that generates charts and graphs from the data</p><p><strong>Create Reusable Flows</strong>: Save this flow as a template for other data products</p><h3><strong>Wrapping Up</strong></h3><p>And there you have it! You’ve just built an intelligent data assistant that bridges the gap between IBM Data Product Hub and natural language queries. No more context switching between tools, no more writing custom scripts for every data request. Just ask your agent, and it handles the rest.</p><p>The beauty of this approach is that it’s extensible. As your data landscape grows, you can add more tools and capabilities without rewriting everything from scratch. Langflow’s visual interface makes it easy to experiment and iterate.</p><p>Whether you’re a data engineer streamlining your workflow or enabling self-service analytics for your business users, this pattern gives you a solid foundation to build on.</p><p>Now go forth and let your data do the talking! 🚀</p><p>— -</p><p><strong>Questions or feedback?</strong> Drop a comment below or reach out to your friendly neighborhood data team. Happy building!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1195adecfc80" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>