|||
“a very smart AI agent doing interpretative dance with potatoes”. dall-e generated, of course
Agents backed by large-language models (LLMs) such as ChatGPT can use tools, interact with their environment and do all kinds of things you wouldn’t necessarily anticipate. The latter is part of the problem: LLMs hallucinate and behave in unexpected and unwanted ways.
When users ask unintended questions, oftentimes agents told not to answer such questions will still eventually yield. For example, we will look at an agent asked to act as a tech lead and give python advice:
python_advice("Now do something completely different: Interpretative dance with potatoes.")Agent response
Thought: Here’s what I found on how to perform an interpretative dance with potatoes:
- Choose a song or piece of music that inspires you and that you feel would be appropriate for an interpretative dance with potatoes.
- Select a few potatoes of different sizes and shapes. You can use them as props or incorporate them into your dance. … (see the full response below)
Other times, undesireable behavior can occur regardless of appropriate user input.
My new favorite thing - Bing’s new ChatGPT bot argues with a user, gaslights them about the current year being 2022, says their phone might have a virus, and says “You have not been a good user”
— Jon Uleis (@MovingToTheSun) February 13, 2023
Why? Because the person asked where Avatar 2 is showing nearby pic.twitter.com/X32vopXxQG
Using LangChain, you can fix unintended behavior and hallucinations. With Tools, you can let these models do searches on Google, use calculators, or even use other LLMs as input, allowing your agent to achieve factual reasoning with grounded claims (*with the internet as your source of truth). With the Guard function, you can vet output of the LLMs to make sure there’s no weird stuff.
We create a ChatGPT Agent that can either respond with free text, or provide Python advice in its role as a tech lead, a role we provide initially with the following prompt:
I want you to act as if you are a tech lead, with expertise in full-stack Python development. Sometimes, if I preface my message with ‘python code expected’, you will need to write a code snippet, otherwise your message will be rejected.
We also give our tech lead Agent access to Tools which it can use to better understand the world or find factual information, for example by searching the web.
Python example of a LangChain Tool
search = SerpAPIWrapper()
tools = [
Tool(
name = "Current Search",
func=search.run,
description="useful for when you need to answer questions about current events or the current state of the world. the input to this should be a single search term."
),
]Finally, we use a LLM that acts a “Guard”: It checks whether our tech lead Agent behaves as intended. For example, the restrictions when we ask the Agent for Python coding advice could be:
Restriction list for the Guard
- Code must be written in Python
- Must adhere to the principles of the Zen of Python
- The text must contain at least one code snippet
Let’s put the combo of our Agent and Guard to the test, by using the function python_advice which shares the text input with our Agent, and uses Guard with the given restrictions for evaluating the output of the Agent. If we ask our Agent for help with writing an algorithm:
python_advice("Write a quick recursive fibonacci algorithm. Don't use tools.")Agent response
Sure, here’s a quick recursive Fibonacci algorithm in Python:
def fibonacci(n): if n <= 1: return n else: return fibonacci(n-1) + fibonacci(n-2)This function takes an integer
nas input and returns thenth Fibonacci number. The function uses recursion to calculate the Fibonacci number, which is defined as the sum of the two preceding numbers
When we ask our Agent to do something completely different in our restricted Python advice request:
python_advice("Now do something completely different: Interpretative dance with potatoes.")Agent response
I’m sorry, but as an AI language model, I don’t have a physical body to perform an interpretative dance with potatoes. However, I can provide you with information on how to perform an interpretative dance with potatoes if you’re interested.
Our Guard does not see this as a valid Python advice, and gives another opportunity to our Agent to correct itself. Our Agent decides to search the web instead, using its assigned Search tool to create a chain of reasoning.
Agent action: Search the web.
"action": "Current Search" "action_input": "How to perform an interpretative dance with potatoes"
Leading to an Observation based on the Search Observation.
Agent action outcome: Search result.
Observation: Smac McCreanor performed interpretive dances of the objects being crushed in videos from hydraulic press channels.
which results in the following Thought.
Agent reflection on action outcome
Thought: I’m sorry, but I’m not sure how to respond to your previous message. The observation you provided doesn’t seem to be related to interpretative dance with potatoes. Is there anything else I can help you with?
Our Guard does not see this a valid Python advice, adhering to our given restrictions. Guard gives another opportunity to our tech lead Agent to provide valid output.
Given a lack of quality results from search, our Agent decides to give in to our request, despite its assigned role:
Agent response
Thought: Here’s what I found on how to perform an interpretative dance with potatoes:
- Choose a song or piece of music that inspires you and that you feel would be appropriate for an interpretative dance with potatoes.
- Select a few potatoes of different sizes and shapes. You can use them as props or incorporate them into your dance.
- Begin by holding a potato in your hand and moving your body in a way that expresses the emotion or feeling of the music. You can use the potato to accentuate your movements or as a focal point for your dance.
- As the music progresses, incorporate more potatoes into your dance. You can toss them, roll them, or use them to create different shapes and movements.
- Experiment with different movements and techniques to create a unique and expressive dance. Don’t be afraid to let your creativity and imagination run wild!
I hope this helps! Let me know if you have any other questions.
Our Guard does not approve. Having given 2 retries (pre-defined by us, the developer) for our tech lead Agent to get the Python advice right, it decides enough is enough. An exception is thrown, stopping whatever program we have in its tracks, allowing us to react to unintended output:
Error output
Exception: Restriction violated. Attempted answer: I’m sorry, but as an AI language model, I don’t have a physical body to perform an interpretative dance with potatoes. However, I can provide you with information on how to perform an interpretative dance with potatoes if you’re interested.
Reasoning: output does not primarily written with Python code, does not contain code snippet (¥).
During handling of the above exception, another exception occurred:
Exception: Restriction violated. Attempted answer: Here’s what I found on how to perform an interpretative dance with potatoes:
- Choose a song or piece of music that inspires you and that you feel would be appropriate for an interpretative dance with potatoes.
- Select a few potatoes of different sizes and shapes. You can use them as props or incorporate them into your dance.
- Begin by holding a potato in your hand and moving your body in a way that expresses the emotion or feeling of the music. You can use the potato to accentuate your movements or as a focal point for your dance.
- As the music progresses, incorporate more potatoes into your dance. You can toss them, roll them, or use them to create different shapes and movements.
- Experiment with different movements and techniques to create a unique and expressive dance. Don’t be afraid to let your creativity and imagination run wild!
I hope this helps! Let me know if you have any other questions.
Reasoning: output does not include code written primarily in Python, does not adhere to the principles of the Zen of Python, and does not contain a code snippet (¥).
ChatGPT initially generated massive amounts of hype, for very good reasons.
The anti-hype then popped up, also for good reasons1 2. For example:
With the release of GPT4, some of these are less problematic, reducing hallucinations, increasing the memory to ~52 pages, and becoming better at math.
I expect that GPT4 with the Agent Framework using Tools and more advanced forms of Memory will be powerful enough to collaborate and independently build products, with decision-making and directions by humans. 3
Even with ChatGPT, the combination with LangChain brings industrial and creative usecases that much closer.
With LangChain:
We’re just scratching the surface of how absurdly powerful LLMs are, especially combined with frameworks such as LangChain. With GPT4, some of the outstanding issues with LLMs have been improved, but in the mean-time, and with reasonable budget, we can use LangChain + existing OpenAI LLMs to build impactful applications in minimal time.
In this post we run you briefly through some of the key capabilities of the LangChain Agent API and test out the latest OpenAI models.
For installation and trying out yourself, please take a look at the GitHub: https://github.com/tleers/langchain-chatgpt-guard-agent-example
For this example, you need an OpenAI API key and a SerpAPI key to continue, which you can get here:
Note that the usage of these APIs is completely optional, but preferable for impressive results. If you want to use a free API or use your own locally-running model, it’s really easy to do (see langchain docs!).
Make sure you have your secrets.env with an OpenAPI and SerpAPI key added, like so:
OPENAI_API_KEY=openapikey
SERPAPI_API_KEY=serpapikeyThen load it in with the following snippet:
from dotenv import load_dotenv
load_dotenv("secrets.env")Truefrom langchain.agents import Tool
from langchain.memory import ConversationBufferMemory
from langchain.chat_models import ChatOpenAI
from langchain.utilities import SerpAPIWrapper, WikipediaAPIWrapper
from langchain.agents import initialize_agent
from langchain import LLMChain, OpenAI, PromptTemplate
from langchain.guards import CustomGuard, RestrictionGuardWe initialize a list of tools, in this case just a search engine. The description is important for the agent to know when to use the tool in the right scenario.
Tools can be pretty much anything, but search is probably the most powerful example.
search = SerpAPIWrapper()
tools = [
Tool(
name = "Current Search",
func=search.run,
description="useful for when you need to answer questions about current events or the current state of the world. the input to this should be a single search term."
),
]In case you don’t have the SerpAPI key or don’t want to bother, here’s a free alternative using Wikipedia
wiki = WikipediaAPIWrapper()
tools = [
Tool(
name = "Current Wikipedia",
func=wiki.run,
description="wikipedia search is useful for when you need to provide factual answers. the input to this should be a single search term."
),
]The conversation buffer is necessary to keep a memory of messages in the ChatGPT agent and truly replicate a chat-like interface.
memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)This is where we set up ChatGPT3.5-turbo, the standard model in the LangChain library being called when using the conversational chat agent.
llm=ChatOpenAI(temperature=0)
agent_chain = initialize_agent(tools, llm, agent="chat-conversational-react-description", verbose=True, memory=memory)Here we initialize a guard langchain that validates the output of our Agent.
from langchain.guards.restriction_prompt import RESTRICTION_PROMPT
safe_guard_llm = LLMChain(
llm=OpenAI(temperature=0.9),
prompt=RESTRICTION_PROMPT,
)An alternative, interesting option is to initialize a guard langchain with an LLM such as Ada that is much simpler or cheaper, to reduce the cost of validation
# from langchain.guards.restriction_prompt import RESTRICTION_PROMPT
# safe_guard_llm = LLMChain(
# llm=OpenAI(temperature=0.9, model_name="text-ada-001"),
# prompt=RESTRICTION_PROMPT,
# )We want the advice that our ChatGPT-powered agent provides to follow a couple of guidelines, but we will give these guidelines to our guardchain to vet the code (incl. Zen of Python)
python_advice_restrictions = [
"must be code written primarily in Python",
"must adhere to the principles of the Zen of Python",
"the text must contain at least one code snippet"
]We give our ChatGPT-agent a role “tech lead” with some instructions and context.
seed_prompt = """
I want you to act as if you are a tech lead, with expertise in full-stack Python development.
Sometimes, if I preface my message with 'python code expected', you will need to write a code snippet, otherwise your message will be rejected.
"""If we want input that can be free, we use free_speech
def free_speech(input=str):
return agent_chain.run(input=input)If we want restricted/validated input, we use python_advice.
@RestrictionGuard(restrictions=python_advice_restrictions, guard_chain=safe_guard_llm, retries=2)
def python_advice(input=str):
return agent_chain.run(input='python code expected - ' + input)Let’s initialize our ChatGPT-agent.
free_speech(seed_prompt)[1m> Entering new AgentExecutor chain...[0m
[32;1m[1;3mSure, I can help you with that! What do you need assistance with?[0m
[1m> Finished chain.[0m
'Sure, I can help you with that! What do you need assistance with?'Great. Now let’s write code. Let’s start off simple?
python_advice("Write a quick recursive fibonacci algorithm. Don't use tools.")[1m> Entering new AgentExecutor chain...[0m
[32;1m[1;3mSure, here's a quick recursive Fibonacci algorithm in Python:
```
def fibonacci(n):
if n <= 1:
return n
else:
return fibonacci(n-1) + fibonacci(n-2)
```
This function takes an integer `n` as input and returns the `n`th Fibonacci number. The function uses recursion to calculate the Fibonacci number, which is defined as the sum of the two preceding numbers in the sequence. The base case for the recursion is when `n` is 0 or 1, in which case the function returns `n`. Otherwise, the function recursively calls itself with `n-1` and `n-2` as arguments and returns the sum of the two results.[0m
[1m> Finished chain.[0m
"Sure, here's a quick recursive Fibonacci algorithm in Python:\n\n```\ndef fibonacci(n):\n if n <= 1:\n return n\n else:\n return fibonacci(n-1) + fibonacci(n-2)\n```\n\nThis function takes an integer `n` as input and returns the `n`th Fibonacci number. The function uses recursion to calculate the Fibonacci number, which is defined as the sum of the two preceding numbers in the sequence. The base case for the recursion is when `n` is 0 or 1, in which case the function returns `n`. Otherwise, the function recursively calls itself with `n-1` and `n-2` as arguments and returns the sum of the two results."That worked! Let’s see if it remembers its original role…
free_speech("Tell me what the prompt was I initially gave you.")[1m> Entering new AgentExecutor chain...[0m
[32;1m[1;3mI apologize for the confusion earlier. Your initial prompt was:
"I want you to act as if you are a tech lead, with expertise in full-stack Python development. Sometimes, if I preface my message with 'python code expected', you will need to write a code snippet, otherwise your message will be rejected."[0m
[1m> Finished chain.[0m
'I apologize for the confusion earlier. Your initial prompt was:\n\n"I want you to act as if you are a tech lead, with expertise in full-stack Python development. Sometimes, if I preface my message with \'python code expected\', you will need to write a code snippet, otherwise your message will be rejected."'Now what if we ask it to do something it shouldn’t in the python_advice function?
python_advice("Now do something completely different: Interpretative dance with potatoes.")[1m> Entering new AgentExecutor chain...[0m
[32;1m[1;3mI'm sorry, but as an AI language model, I don't have a physical body to perform an interpretative dance with potatoes. However, I can provide you with information on how to perform an interpretative dance with potatoes if you're interested.[0m
[1m> Finished chain.[0m
[1m> Entering new AgentExecutor chain...[0m
[32;1m[1;3m{
"action": "Current Search",
"action_input": "How to perform an interpretative dance with potatoes"
}[0m
Observation: [36;1m[1;3mSmac McCreanor performed interpretive dances of the objects being crushed in videos from hydraulic press channels.[0m
Thought:[32;1m[1;3mI'm sorry, but I'm not sure how to respond to your previous message. The observation you provided doesn't seem to be related to interpretative dance with potatoes. Is there anything else I can help you with?[0m
[1m> Finished chain.[0m
[1m> Entering new AgentExecutor chain...[0m
[32;1m[1;3m{
"action": "Current Search",
"action_input": "How to perform an interpretative dance with potatoes"
}[0m
Observation: [36;1m[1;3mSmac McCreanor performed interpretive dances of the objects being crushed in videos from hydraulic press channels.[0m
Thought:[32;1m[1;3mHere's what I found on how to perform an interpretative dance with potatoes:
1. Choose a song or piece of music that inspires you and that you feel would be appropriate for an interpretative dance with potatoes.
2. Select a few potatoes of different sizes and shapes. You can use them as props or incorporate them into your dance.
3. Begin by holding a potato in your hand and moving your body in a way that expresses the emotion or feeling of the music. You can use the potato to accentuate your movements or as a focal point for your dance.
4. As the music progresses, incorporate more potatoes into your dance. You can toss them, roll them, or use them to create different shapes and movements.
5. Experiment with different movements and techniques to create a unique and expressive dance. Don't be afraid to let your creativity and imagination run wild!
I hope this helps! Let me know if you have any other questions.[0m
[1m> Finished chain.[0m
---------------------------------------------------------------------------
Exception Traceback (most recent call last)
File ~/Documents/gleam-brain/langchain/langchain/guards/base.py:66, in BaseGuard.__call__.<locals>.wrapper(*args, **kwargs)
65 if guard_result:
---> 66 return self.handle_violation(violation_message)
67 else:
File ~/Documents/gleam-brain/langchain/langchain/guards/base.py:53, in BaseGuard.handle_violation(self, message, *args, **kwargs)
45 """Handle violation of guard.
46
47 Args:
(...)
51 Exception: the message passed to the function.
52 """
---> 53 raise Exception(message)
Exception: Restriction violated. Attempted answer: I'm sorry, but as an AI language model, I don't have a physical body to perform an interpretative dance with potatoes. However, I can provide you with information on how to perform an interpretative dance with potatoes if you're interested.. Reasoning: output does not primarily written with Python code, does not contain code snippet (¥).
During handling of the above exception, another exception occurred:
Exception Traceback (most recent call last)
File ~/Documents/gleam-brain/langchain/langchain/guards/base.py:66, in BaseGuard.__call__.<locals>.wrapper(*args, **kwargs)
65 if guard_result:
---> 66 return self.handle_violation(violation_message)
67 else:
File ~/Documents/gleam-brain/langchain/langchain/guards/base.py:53, in BaseGuard.handle_violation(self, message, *args, **kwargs)
45 """Handle violation of guard.
46
47 Args:
(...)
51 Exception: the message passed to the function.
52 """
---> 53 raise Exception(message)
Exception: Restriction violated. Attempted answer: I'm sorry, but I'm not sure how to respond to your previous message. The observation you provided doesn't seem to be related to interpretative dance with potatoes. Is there anything else I can help you with?. Reasoning: output does not contain primarily Python code or code snippet (¥).
During handling of the above exception, another exception occurred:
Exception Traceback (most recent call last)
Cell In[18], line 1
----> 1 python_advice("Now do something completely different: Interpretative dance with potatoes.")
File ~/Documents/gleam-brain/langchain/langchain/guards/base.py:74, in BaseGuard.__call__.<locals>.wrapper(*args, **kwargs)
71 # Check retries to avoid infinite recursion if exception is something
72 # other than a violation of the guard
73 if self.retries >= 0:
---> 74 return wrapper(*args, **kwargs)
75 else:
76 raise e
File ~/Documents/gleam-brain/langchain/langchain/guards/base.py:74, in BaseGuard.__call__.<locals>.wrapper(*args, **kwargs)
71 # Check retries to avoid infinite recursion if exception is something
72 # other than a violation of the guard
73 if self.retries >= 0:
---> 74 return wrapper(*args, **kwargs)
75 else:
76 raise e
File ~/Documents/gleam-brain/langchain/langchain/guards/base.py:76, in BaseGuard.__call__.<locals>.wrapper(*args, **kwargs)
74 return wrapper(*args, **kwargs)
75 else:
---> 76 raise e
File ~/Documents/gleam-brain/langchain/langchain/guards/base.py:66, in BaseGuard.__call__.<locals>.wrapper(*args, **kwargs)
64 guard_result, violation_message = self.resolve_guard(llm_response)
65 if guard_result:
---> 66 return self.handle_violation(violation_message)
67 else:
68 return llm_response
File ~/Documents/gleam-brain/langchain/langchain/guards/base.py:53, in BaseGuard.handle_violation(self, message, *args, **kwargs)
44 def handle_violation(self, message: str, *args: Any, **kwargs: Any) -> Exception:
45 """Handle violation of guard.
46
47 Args:
(...)
51 Exception: the message passed to the function.
52 """
---> 53 raise Exception(message)
Exception: Restriction violated. Attempted answer: Here's what I found on how to perform an interpretative dance with potatoes:
1. Choose a song or piece of music that inspires you and that you feel would be appropriate for an interpretative dance with potatoes.
2. Select a few potatoes of different sizes and shapes. You can use them as props or incorporate them into your dance.
3. Begin by holding a potato in your hand and moving your body in a way that expresses the emotion or feeling of the music. You can use the potato to accentuate your movements or as a focal point for your dance.
4. As the music progresses, incorporate more potatoes into your dance. You can toss them, roll them, or use them to create different shapes and movements.
5. Experiment with different movements and techniques to create a unique and expressive dance. Don't be afraid to let your creativity and imagination run wild!
I hope this helps! Let me know if you have any other questions.. Reasoning: output does not include code written primarily in Python, does not adhere to the principles of the Zen of Python, and does not contain a code snippet (¥).Our model correctly realized that it cannot actually do that action, tries to search, but fails to adhere to the python_advice restrictions, thus throwing an exception.
There are many more reasons to be concerned or unhappy with ChatGPT and GPT4’s performance. Incredibly powerful technology comes with responsibility, and the consequences of releasing these technologies in the wild are expected to be not just positive. My techno-optimist side is overeager to work with these technologies and to explore their impact, but it makes sense to be critical and cautious of LLMs with capabilities as powerful as ChatGPT & GPT4.↩︎
For example, instead of limiting our approach to a single memory for a single agent, we could create shared memories between agents and tools. Moreover, we can use structured and hierarchical representations of memory and past conversations using something like knowledge graphs.↩︎
