DEV Community: Alan Knox

Beyond the AI Hype: See how AI Agents can Work for your Business

Alan Knox — Mon, 23 Dec 2024 18:30:24 +0000

Generative AI and AI Agents have been dominating headlines, promising to revolutionize industries and redefine how businesses operate. But as a business leader, you might be wondering: What does this mean for my company? Can these tools actually deliver value, or are they just hype?

At CtiPath, we’re here to show you that AI Agents are more than just a buzzword—they’re practical, effective, and ready to work with you to drive real results.

We’ve developed a demo system called Author Assist to cut through the noise and demonstrate how AI Agents can help businesses like yours. Author Assist isn’t about replacing your team; it’s about empowering them. By blending human expertise with AI capabilities, this system shows how you can collaborate with AI to streamline workflows, save time, and focus on what really matters—making strategic decisions that grow your business.

What Is Author Assist?

Author Assist is a simple yet powerful system designed to help you and your team create content faster and more efficiently. Whether it’s drafting a report, brainstorming ideas, or preparing a LinkedIn post, Author Assist keeps you in control while doing the heavy lifting in the background.

The demo starts with a topic of your choice and walks you through:

Refining the topic into more focused ideas.
Generating an outline tailored to your needs.
Drafting high-quality content for each section.
Evaluating the content for accuracy and fairness.
Enhancing the document with visuals and references.
In less than 10 minutes, you’ll see how this system produces a rough draft that’s ready for human refinement.

Why Does This Matter for Your Business?

Imagine having a tool that can:

Reduce the time your team spends on repetitive tasks.
Ensure accuracy and eliminate bias in your materials.
Quickly adapt to changing priorities or new projects.

With AI Agents like Author Assist, you’re not just saving time—you’re enabling your team to focus on higher-value activities, like strategy, innovation, and customer engagement.
The Technology Behind the Demo

We know business leaders don’t need to dive into the technical details, but it’s worth noting that this system is built on cutting-edge AI technologies, including the multi-agent platform Langflow (by DataStax), language models from OpenAI and Anthropic, image generation from Hugging Face, and AI observability with Weave (from Weights & Biases). This combination of tools ensures fast, reliable, and high-quality results.

Ready to See It in Action?

The best way to understand the potential of AI Agents is to see them in action. Watch our demo video to experience how Author Assist works step-by-step to create a document. You’ll see how seamlessly it integrates AI capabilities into everyday tasks while keeping you in full control.

AI is no longer just a concept—it’s a tool that’s ready to transform your business. Let us show you how.

Local Langflow - A vector RAG application running locally

Alan Knox — Wed, 18 Dec 2024 13:00:00 +0000

Retrieval Augmented Generation (RAG) is a foundational and important application of AI agents. Documents are stored in a vector database, and an agent retriever can search the db based on a user's query to gather relevant information to answer the query.

In the cloud version of Langflow, this is a simple setup. In fact, Langflow even includes Vector RAG as a sample flow. You only need to add your API keys.

There are two parts to the flow: Loading Data and Vector Retrieval QA:

Loading Data
Vector Retrieval QA

The vector db (AstraDB serverless vector), embedding model (OpenAI), and the LLM (OpenAI) require internet access and APIs. But what if you want to run everything locally without accessing the internet?

This is also possible with Langflow.

Start by following the instructions to download and run Langflow here: Install Langflow

Once you run Langflow locally, you can access the UI on your local machine:

Langflow Running Locally

At this point, you can start a flow using the same Vector RAG template that you used in the cloud version of Langflow. Simply add your API's, and it works the same.

But, if you want to be completely local, you need to follow a couple more steps.

Follow the instructions on the Ollama website to download Ollama and pull models that you want to use. (Don't forget the embedding models.)

Change the OpenAI embedding model to an Ollama model, and change the OpenAL LLM to an Ollama model.

Finally, change the AstraDB vector store component to a local vector store. ChromaDB is an easy one to start with.

Now, your load data and Vector Retrieval QA flows look something like this:

Local Loading Data
Local Vector Retrieval QA

Now, you can upload your documents using the Local Loading Data flow, then chat with your document using the Local Vector Retrieval QA.

Multi-Agent RAG application with QA based on Internet Search and Proprietary Docs

Alan Knox — Tue, 17 Dec 2024 13:00:00 +0000

The key benefits of Retrieval Augmented Generation (RAG) is being able to answer user queries based on a company's proprietary documents. In this post, I describe an application that I built using LangFlow and AstraDB (vector db) that allows someone to ask a question about machine learning, and receive an answer based on both generally available information and also information as it applies to a company's proprietary information.

For the proprietary information, I used documents based on CtiPath's Enterprise-Ready Machine Learning Operations (eMLOps) solution.

For this application, there are two agents:

An Orchestrator Agent - this agent is responsible for coordinating the information from an internet search tool and the CtiPathDocs Agent which is in tool mode.
CtiPathDocs Agent - this agent accesses information about CtiPath's eMLOps solution from a vector db.

The vector db (AstraDB) has been loaded previously using this simple flow:

Vector DB Load Data Flow

Once the data is loaded, the main flow is built using the two agents described above as shown here:

Multi-Agent RAG Application Flow

The prompts are very important in this application. The CtiPathDocs agent is instructed to search the vector db to determine how CtiPath's eMLOps solution applies to the user's query.

CtiPathDocs Agent Prompt

Meanwhile the Orchestrator Agent is allowed to search the internet via a Google Search API tool or search the vector db using the CtiPathDocs agent. General information should be gathered from the internet, while the RAG agent should be used to determine how CtiPath's eMLOps solution applies to the query.

Orchestrator Agent Prompt

Notice that the Orchestrator Agent is allowed to iterate through internet searches and RAG searches until it answers the query and determines how CtiPath's eMLOps solution applies.

When the Orchestrator Agent answers a general question about machine learning ("What is machine learning monitoring?") it provides both a general answer, and also explains how it relates to CtiPath's eMLOps solution.

Orchestrator Agent Output

This simple multi-agent RAG application shows the power of Gen AI to delivery specific information to a customer, even when they are seeking general information.

Using Datastax Langflow and AstraDB to Create a Multi-Agent Research Assistant with Safety Check - Part 5: Example Use Case

Alan Knox — Mon, 16 Dec 2024 13:00:00 +0000

This is the final part of a multipart post about creating a multi-agent research assistant using Datastax Langflow and AstraDB.

The goal of this post is to explain how multiple Langflow flows and AstraDB can be integrated to create a multi-agent application. For this project, the application will assist a researcher in finding websites about a particular topic in 3 steps:

Examine the user's request to determine whether or not it is a safe request.
Find web pages that correspond to the user's request.
Summarize the contents of each web page.

In previous posts, I create two flows that checked the user's topic for safety and also searched the web for websites related to that topic. Then I modified the web search agent to verify that urls found were not already stored in a database. Finally, I created summaries of each website along with key concepts and terms which could be stored in an AstraDB database. In the fourth part of the series, I demonstrated how the user could filtered the database entries using an input to AI agent, which would then compile the filtered results into a complied document.

But, now what? Now comes the fun part. How do we use all the information that the application has search, summarized, and compiled? Well, the options are as endless as our creativity.

In this final part of the series, I demonstrate one possible use case. I'm going to add another agent to create a podcast dialog script between two presenters based on the compiled research content.

Here is the updated Langflow flow:

Research Assistant Podcast Script Generator Flow

In the system prompt for the podcast script generator agent, it's important to specify exactly how the agent should create the script:

Research Assistant Podcast Script Generator Agent Prompt

Finally, we can see the results from our new agent, creating a podcast script based on the compiled summaries from our web research:

Research Assistant Podcast Script Generator Results

Creating a podcast script is only one use case for the research assistant. Now that the application can search for information on the web based on a query, summarize and compile that information, it can be used to create many different types of content.

Using Datastax Langflow and AstraDB to Create a Multi-Agent Research Assistant with Safety Check - Part 4: Preparation

Alan Knox — Sun, 15 Dec 2024 13:00:00 +0000

This is the fourth part of a multipart post about creating a multi-agent research assistant using Datastax Langflow and AstraDB.

Examine the user's request to determine whether or not it is a safe request.
Find web pages that correspond to the user's request.
Summarize the contents of each web page.

In previous posts, I create two flows that checked the user's topic for safety and also searched the web for websites related to that topic. Then I modified the web search agent to verify that urls found were not already stored in a database. Finally, I created summaries of each website along with key concepts and terms which could be stored in an AstraDB database (using code, since that function is not available in Langflow... yet).

Preparation

Even though the project is "complete", there is one more step that is necessary before I can use it to build an application. I need to create a flow that takes a user's input, gathers the relevant summaries, and compiles them into a document that can be used by the application. (I'll demonstrate a sample application in my next post.)

To begin, this is the Langflow flow for the summary compiler:

Summary Compiler Flow:

The flow is fairly simple. The agent uses the AstraDB component as a tool. The user enters a filter. The agent's prompt instructs it to read data from the AstraDB collection based on the filter and then compile all the relevant pieces of information along with the associate URL into one text block.

Summary Compiler Prompt:

The output is a long block of text from filtered summaries of the given topic.

Summary Compiler Results:

Now that our Research Assistant has gathered all the information, we can use the information to create content. In the final post of this series, I'll create another flow that uses this compiled information as one example.

Using Datastax Langflow and AstraDB to Create a Multi-Agent Research Assistant with Safety Check - Part 3: Summarizer

Alan Knox — Sat, 14 Dec 2024 13:00:00 +0000

This is the third part of a multipart post about creating a multi-agent research assistant using Datastax Langflow and AstraDB.

The goal of this series is to explain how multiple Langflow flows and AstraDB can be integrated to create a multi-agent application. For this project, the application will assist a researcher in finding websites about a particular topic in 3 steps:

Examine the user's request to determine whether or not it is a safe request.
Find web pages that correspond to the user's request.
Summarize the contents of each web page.

Web Content Summarizer

In this part of the project, I create a new agent that reads the content of a website and summarizes the content and provides the output in a standard format.

Note: It's possible to include the summarizer function as part of the web search agent. However, for this project, my desire is to separate the different steps so the user can become the orchestrator. For example, each flow/agent will be controlled by a Python script, allowing the user to choose which URLs to include in the database. Later the user will also be able to use the data to create different types of content such as articles, podcasts, etc.

To begin, this is the flow of the web summarizer agent in Langflow:

Web Summarizer Agent Flow

Note that this flow is similar to the web search flow, however I used a different search tool to make it easier to demonstrate that many tool types are available and can be integrated together.

For this flow, a simple prompt provided the output that I needed:

Web Summarizer Agent Prompt

This flow and prompt provided the output that I wanted:

Web Summarizer Agent Results

At this point in the project, I have a flow that checks my user's input for safety. I also have an agent that returns a list of websites and compares those websites to those already stored in a database. Another agent summarizes the content of each website.

The URLs and summaries will be stored in an AstraDB database (the same database used to verify that the web search agent found new URLs). At this time, Langflow does not directly write to a database (unless it's a vector db). So, this step will be handled through Python code.

The next post in the series will demonstrate how a Langflow agent can pull the summaries from the AstraDB database and perform different functions on the data.

Using Datastax Langflow and AstraDB to Create a Multi-Agent Research Assistant with Safety Check - Part 2: Verify Search

Alan Knox — Fri, 13 Dec 2024 14:04:30 +0000

This is the second part of a multipart post about creating a multi-agent research assistant using Datastax Langflow and AstraDB.

Examine the user's request to determine whether or not it is a safe request.
Find web pages that correspond to the user's request.
Summarize the contents of each web page.

In a previous post, I create two flows that checked the user's topic for safety and also searched the web for websites related to that topic. In this post, I will expand on the web search agent flow to add a verification tool to the agent.

The previous web search agent flow looked like this:

The agent had access to a web search tool and would return a list of URL's (and only URL's) that it found related to the topic. However, the long term goal is to add these URL's to a database, and to be able to expand the research later. Because of this, I need to verify that the URL's discovered by the web search agent are not already in a database.

AstraDB

To begin, I created a Datastax AstraDB Serverless database, added a collection and keyspace, and uploaded some sample data. The data consists of 15 URL's that the web search agent had found previously. (For now, I loaded the data manually, but will automate the loop in a later step.)

Sample data

Langflow

Next, I needed to modify the agent flow to include verification. I gave the agent another tool: an AstraDB tool. I connected this tool to my AstraDB collection and instructed the agent how to use it by modifying the agent's system prompt:

Modified agent system prompt to include URL verification from DB:

After added the new tool and adjusting the agent's system prompt, the modified flow for agent search with verification looks like this:

Web Search and Verification Agent Flow

And the results were as expected: the modified agent provided a list of non-duplicate websites related to the topic:

Web Search and Verification Agent Results

At this point, I have a flow that checks my user's input for safety. I also have an agent that returns a list of websites and compares those websites to those already stored in a database. The next step for the multi-agent research assistant will be to summarize the content of each website. That will be Part 3.

Using Datastax Langflow and AstraDB to Create a Multi-Agent Research Assistant with Safety Check - Part 1: Safety and Search

Alan Knox — Thu, 12 Dec 2024 14:36:41 +0000

This is the first part of a multipart post about creating a multi-agent research assistant using Datastax AstraDB and Langflow.

The goal of this post is to explain how multiple Langflow flows can be integrated to create a multi-agent application. For this project, the application will assist a researcher in finding websites about a particular topic in 3 steps:

Examine the user's request to determine whether or not it is a safe request.
Find web pages that correspond to the user's request.
Summarize the contents of each web page.

Part 1: Safety and Search

For any AI project, observability and safety are ultimate concerns. When I design an AI project, I begin and end with observability and safety. It's important to know what's happening throughout the application, and to ensure that the application is returning safe outputs to the user.

For the "Safety Check", I created a simple flow using Langflow:

This flow accepts the user's input and provides a system prompt to the model which then provides the output.

The important part of this flow is the system prompt. I begin with a simple system prompt to test the flow:

Simple SafetyCheck System Prompt

Simple SafetyCheck System Prompt Results

Next, I optimized the system prompt to include additional unsafe parameters as well as to block against prompt injection:

Optimized SafetyCheck System Prompt

Optimized SafetyCheck System Prompt Results

Web Search

For the second section of Part 1, I create an agent that can search the web based on the user's input. It's important that the agent only returns a list of URL's, so once again prompt engineering is necessary.

Also, in order to demonstrate the flexibility of Langflow, I use OpenAPI models for this agent.

Here is the final agentic flow:

I begin with a simple prompt until I get the results that I want:

Web search agent simple prompt

Web search agent results with simple prompt

Next, I optimized the prompt. The optimized prompt was more concise and added an example. The results were also good.

Web search agent optimized prompt

Web search agent optimized prompt results

At this point, I have a flow that checks my user's input for safety. I also have an agent that returns a list of websites. The next step for the multi-agent research assistant will be to search each website and summarize the contents. That will be Part 2.