Supercharge Marketing AI Agents Unleashing Human-in-the-Loop Content Creation

Elevating Marketing with Human-in-the-Loop AI Agents

AI agents are streamlining tasks, and they're not just for tech giants anymore. With a human-in-the-loop, you can build one yourself and oversee the process.

Generating engaging promotional content across different social media platforms, its a big challenge for a lot of marketing teams. Traditionally, a project leader would delegate tasks to content writers and digital artists, which can be time-consuming. But what if ai agents could make this more streamlined?

One use case involves two ai agents, the Content Creator Agent and the Digital Artist Agent. The content creator agent uses the Llama 3.1 405B model, and it gets accelerated by nvidia nim microservices. The digital artist agent transforms promotional text into visuals using the nvidia sdXL-turbo text-to-image model.

To maintain human oversight, the agents will share their outputs for final approval. The Marketer or project lead, as the human decision-maker, will review both the text generated by the Content Creator Agent and the artwork produced by the Digital Artist Agent.

This human-in-the-loop approach ensures the final product is polished and on-brand. NVIDIA also provides tools, and with NIM microservices, you can scale your ai-driven tasks with efficiency and flexibility. It also helps you accelerate content production and reduces manual effort.

By incorporating ai agents into your workflow, you can speed up content creation, reduce manual labor, and keep full control. Now, lets talk about how these agents can transform marketing.

Introducing NVIDIA NIM Microservices The AI Agent Engine

So, wanna build an ai agent that actually helps with marketing? Turns out, it's not as hard as you might think. You can even keep a human in the loop to make sure things don't go off the rails.

ai agents, especially when they're powered by large language models (llms), can seriously streamline content creation. The key is to make sure a human is always checking the work, just in case. As that NVIDIA blog post mentions, it's essential to maintain human oversight when you're dealing with autonomous ai.

One way to do this is to use two ai agents: a Content Creator and a Digital Artist. The Content Creator Agent comes up with the promo messages, and the Digital Artist Agent turns those messages into eye-catching visuals.

• The Content Creator Agent uses the Llama 3.1 405B model, which gets a boost from nvidia nim microservices.
• The Digital Artist Agent uses the nvidia sdXL-turbo text-to-image model to make those visuals pop.

But here's the kicker: these agents don't just run wild, they share their work with a human decision-maker for approval. This human-in-the-loop approach makes sure the final product is on-brand and ready to go. nvidia also has tools to help you scale your ai-driven tasks with both efficiency and flexibility.

NVIDIA NIM microservices are accelerated APIs optimized for AI inference

Incorporating ai agents into your workflow can speed things up, cut down on manual work, and keep you in control.

Now, let's talk about what nvidia NIM microservices actually are and how they can help you.

Building a Human-in-the-Loop AI Agent A Step-by-Step Guide

So, you're ready to dive in and actually build one of these human-in-the-loop ai agents? It's not as scary as it sounds, trust me. This section will walk you through the steps.

One of the biggest challenges for marketing teams is creating engaging content across different social media platforms. Traditionally, a project leader would delegate tasks to content writers and digital artists, which can be a time-consuming process. But what if ai agents could make this more streamlined?

This particular use case involves two ai agents: the Content Creator Agent and the Digital Artist Agent. The goal is to have these agents generate promotional content and then submit it for human approval, keeping that human element front and center.

Building this system involves a cognitive workflow where ai agents assist in specific tasks, while a human makes the final decisions. As that NVIDIA blog post shows, you can outline the interaction between the human and the ai like this:

graph LR
A[Human Decision-Maker] --> B{Content Creator Agent}
A --> C{Digital Artist Agent}
B -- Promotion Text --> D[Review & Approval]
C -- Artwork --> D
D --> E{Social Media Platforms}

• The Content Creator Agent uses the Llama 3.1 405B model, accelerated by NVIDIA LLM nim microservices.
• LangChain ChatNVIDIA with nim functional calling and structured output are also integrated to ensure organized, reliable results.
• These combined capabilities are built into LangChain runnable chain expressions, creating a robust agent workflow.

Start by putting together the Content Creator Agent. This agent generates promotional messages following specific formatting guidelines, using the nvidia api catalog preview API endpoints. nvidia AI Enterprise customers can also download and run NIM endpoints locally.

Next up is the Digital Artist Agent, which turns promotional text into creative visuals using the nvidia sdXL-turbo text-to-image model. This agent rewrites input queries and generates high-quality images designed for social media promotion campaigns.

Now that you've got the agents in place, let's talk about integrating the human element. Next, is Using the Digital Artist Agent Code Implementation.

Implementing the Code Integrating Human Oversight

Alright, so how do you actually make this human-in-the-loop thing work? It's not as complicated as it sounds, promise!

To keep things on track, it's essential the agents share their outputs for that final thumbs-up. A human decision-maker which in this case is you, will review the text and the artwork.
This human element allows for iterations, making sure those promotional messages and images? They're polished for launch.

The agentic logic puts humans yeah, you at the center as decision-makers, assigning the right agents to each task.
LangGraph handles the agentic cognitive architecture.

So, what's the code look like? Well, LangGraph is used to orchestrate the agentic cognitive architecture.
That NVIDIA blog post on human-in-the-loop ai agents, it shows a function asking for human input:

from langchain_community.tools import HumanInputRun
from langchain.agents import AgentType, load_tools

def get_human_input() -> str:
""" Put human as decision maker, human will decide which agent is best for the task"""
print("You have been given 2 agents. Please select exactly ONE agent to help you with the task, enter 'y' to confirm your choice.")
print("""Available agents are : \n
1 ContentCreator  \n
2 DigitalArtist \n
Enter 1 or 2""")
contents = []
while True:
try:
line = input()
if line=='1':
tool="ContentCreator"
line=tool
elif line=='2':
tool="DigitalArtist"
else:
pass
except EOFError:
break
print(f"tool selected : {tool} ")
contents.append(line)
return "\n".join(contents)
ask_human = HumanInputRun(input_func=get_human_input)

Then, you create two Python functions as graph nodes, used by LangGraph to represent steps or actions in a workflow.
These nodes allows the agent to execute tasks sequentially or in parallel, creating a structured process:

from langgraph.graph import END, StateGraph
from langgraph.prebuilt import ToolInvocation
from colorama  import Fore,Style

def human_assign_to_agent(state):
ensure using original prompt
inputs = state["input"]
input_to_agent = state["input_to_agent"]
concatenate_str = Fore.BLUE+inputs+ ' : '+Fore.CYAN+input_to_agent + Fore.RESET
print(concatenate_str)
print("---"*10)
agent_choice=ask_human.invoke(concatenate_str)
print(Fore.CYAN+ "choosen_agent : " + agent_choice + Fore.RESET)
return {"agent_choice": agent_choice }
choosen agent will execute the task
choosen_agent = state['agent_choice']
if choosen_agent=='ContentCreator':
structured_respond=content_creator.invoke({"product_desc":input_to_agent})
respond='\n'.join([structured_respond.Title,structured_respond.Message,''.join(structured_respond.Tags)])
elif choosen_agent=="DigitalArtist":
respond=digital_artist.invoke(input_to_agent)
respond="please reselect the agent, there are only 2 agents available: 1.ContentCreator or 2.DigitalArtist"
print(Fore.CYAN+ "agent_output: \n" + respond + Fore.RESET)
return {"agent_use_tool_respond": respond}

Finally, you connect the nodes and edges to form the human-in-the-loop multi-agent workflow.

Now that you know about how the code should be implemented, let's dive into using the Digital Artist Agent code implementation.

Putting it into Action Launching the Human-Agent Workflow

Alright, so now you got the code setup, right? Let's get this human-agent workflow off the ground and see it in action!

• Querying the Content Creator Agent is the initial step. This involves prompting the agent to generate promotional text.
  • You'll need to give it a product description as input.
  • The agent will then whip up a title, a message, and some hashtags.
• Creating Illustrations is the next thing on the list.
  • That Digital Artist Agent comes in handy.
  • You can use the title from the Content Creator Agent as the input for the image prompt.
  • This agent then generates some eye-catching visuals.
• Iterating for High-Quality Results is the final part.
  • Adjusting the input prompts, like tweaking the title, is key.
  • This tells the Digital Artist Agent to generate different variations of artworks.
  • Repeat this until you achieve the results you actually wanted.

As shown in that NVIDIA blog post, this iterative approach lets you fine-tune the outputs until they're just right. Adjusting the input prompt slightly from the Content Creator Agent can yield diverse images from the Digital Artist Agent.

So, you just launched the app, right? Now, it prompts you to assign one of the available agents for the given task. Now, lets see how you can refine the final product.

Refining and Showcasing the Final Product

Alright, so you've got your ai agents doing their thing, huh? Now it's time to make sure everything looks real good before you show it off.

• First, you gotta combine the text and the artwork. Think of it like putting the peanut butter and jelly together, it just needs to be done.
• Then, format it all in markdown. Why markdown? Well, it lets you see how it's gonna look, visually, before it goes live. Makes sense, right?
• Last thing to do is get it ready for deployment. Make sure all the pieces are in place, and all the connections are working.

Now, let's talk about getting that final approval before you ship it.

Conclusion Enhancing AI Agents with NVIDIA NIM and AI Tools

Alright, so how can you make your ai agents even better? Turns out, it's all about the tools.

• NVIDIA NIM microservices lets you scale ai tasks, which is super useful for content creation.
• Human-in-the-loop ai agents, it helps you optimize workflows, whether you're writing messages or making visuals.
• You can boost productivity by using these tools.

NVIDIA also has resources to help you build and use these ai agents. It's all about understanding that human-in-the-loop logic.

Now, wanna check out some other NVIDIA stuff?