A simple Python implementation of the ReAct pattern for LLMs#

1
# This code is Apache 2 licensed:
2
# https://www.apache.org/licenses/LICENSE-2.0
3
import openai
4
import re
5
import httpx
6

7
openai.api_key = "sk-..."
8

9
class ChatBot:
10
    def __init__(self, system=""):
11
        self.system = system
12
        self.messages = []
13
        if self.system:
14
            self.messages.append({"role": "system", "content": system})
15

16
    def __call__(self, message):
17
        self.messages.append({"role": "user", "content": message})
18
        result = self.execute()
19
        self.messages.append({"role": "assistant", "content": result})
20
        return result
21

22
    def execute(self):
23
        completion = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=self.messages)
24
        # Uncomment this to print out token usage each time, e.g.
25
        # {"completion_tokens": 86, "prompt_tokens": 26, "total_tokens": 112}
26
        # print(completion.usage)
27
        return completion.choices[0].message.content
28

29
prompt = """
30
You run in a loop of Thought, Action, PAUSE, Observation.
31
At the end of the loop you output an Answer
32
Use Thought to describe your thoughts about the question you have been asked.
33
Use Action to run one of the actions available to you - then return PAUSE.
34
Observation will be the result of running those actions.
35

36
Your available actions are:
37

38
calculate:
39
e.g. calculate: 4 * 7 / 3
40
Runs a calculation and returns the number - uses Python so be sure to use floating point syntax if necessary
41

42
wikipedia:
43
e.g. wikipedia: Django
44
Returns a summary from searching Wikipedia
45

46
simon_blog_search:
47
e.g. simon_blog_search: Django
48
Search Simon's blog for that term
49

50
Always look things up on Wikipedia if you have the opportunity to do so.
51

52
Example session:
53

54
Question: What is the capital of France?
55
Thought: I should look up France on Wikipedia
56
Action: wikipedia: France
57
PAUSE
58

59
You will be called again with this:
60

61
Observation: France is a country. The capital is Paris.
62

63
You then output:
64

65
Answer: The capital of France is Paris
66
""".strip()
67

68

69
action_re = re.compile('^Action: (\w+): (.*)$')
70

71
def query(question, max_turns=5):
72
    i = 0
73
    bot = ChatBot(prompt)
74
    next_prompt = question
75
    while i < max_turns:
76
        i += 1
77
        result = bot(next_prompt)
78
        print(result)
79
        actions = [action_re.match(a) for a in result.split('\n') if action_re.match(a)]
80
        if actions:
81
            # There is an action to run
82
            action, action_input = actions[0].groups()
83
            if action not in known_actions:
84
                raise Exception("Unknown action: {}: {}".format(action, action_input))
85
            print(" -- running {} {}".format(action, action_input))
86
            observation = known_actions[action](action_input)
87
            print("Observation:", observation)
88
            next_prompt = "Observation: {}".format(observation)
89
        else:
90
            return
91

92

93
def wikipedia(q):
94
    return httpx.get("https://en.wikipedia.org/w/api.php", params={
95
        "action": "query",
96
        "list": "search",
97
        "srsearch": q,
98
        "format": "json"
99
    }).json()["query"]["search"][0]["snippet"]
100

101

102
def simon_blog_search(q):
103
    results = httpx.get("https://datasette.simonwillison.net/simonwillisonblog.json", params={
104
        "sql": """
105
        select
106
          blog_entry.title || ': ' || substr(html_strip_tags(blog_entry.body), 0, 1000) as text,
107
          blog_entry.created
108
        from
109
          blog_entry join blog_entry_fts on blog_entry.rowid = blog_entry_fts.rowid
110
        where
111
          blog_entry_fts match escape_fts(:q)
112
        order by
113
          blog_entry_fts.rank
114
        limit
115
          1""".strip(),
116
        "_shape": "array",
117
        "q": q,
118
    }).json()
119
    return results[0]["text"]
120

121
def calculate(what):
122
    return eval(what)
123

124
known_actions = {
125
    "wikipedia": wikipedia,
126
    "calculate": calculate,
127
    "simon_blog_search": simon_blog_search
128
}