Von Grund auf reagieren: Gedanke, Handlung, Pause, Beobachtung ohne Rahmenwerk

Einführung

Fragen Sie ein Modell in einfachem Sprachstil nach dem aktuellen Preis von Nvidia sowie nach der Anzahl an Aktien, die man mit 100.000 Dollar kaufen kann. Ohne spezielle Tools erfindet es einen veralteten Kurs aus den Trainingsdaten und teilt bei falschen Eingaben zwar korrekt, hat aber keine eingebaute Funktion, die besagt „Ich weiß es nicht – schauen Sie nach“, da eine Suche kein einzelner Durchlauf ist.

Sobald die Qualität der Antworten stieg, erwiesen sich die Modelle als nützlich für einmaliges Reasoning. Allein das Planen garantiert noch keine Autonomie. Die Fragen, die Agenten definieren, lauten: Was liegt außerhalb des Wissens des Modells, welche Aktion führt dazu, wie erzielt man ein Ergebnis, wie überarbeitet man den Plan und wann sollte man aufhören. Entscheidung → Handlung → Überprüfung → Neuplanung ist ein Loop, keine gerade Linie. Dieser Loop ist der Ursprung moderner KI-Agenten. ReAct (Reason + Act) legte das Muster fest. Die ursprünglichen Demonstrationen waren keine LangChain-Apps – es handelte sich um ein LLM, eine strukturierte Anfrage sowie einen Menschen (oder später ein Skript), der Aktionen ausführte und Beobachtungen zurückgab.

Einführung in ReAct: Reasoning + Act

Ein funktionierendes Beispiel, Schritt für Schritt:

from groq import Groq
import re
from dotenv import load_dotenv

_ = load_dotenv()

client = Groq()

message = client.chat.completions.create(
    model="openai/gpt-oss-120b",  # free, fast open-weight model hosted on Groq
    max_tokens=1000,
    messages=[
        {"role": "user", "content": "Hello, GPT!"}
    ],
)

print(message.choices[0].message.content) # Check the client

class Agent:
    def __init__(self, system=""):
        self.system = system
        self.messages = []
        if self.system:
            self.messages.append({"role": "system", "content": system})

    def __call__(self, message):
        self.messages.append({"role": "user", "content": message})
        result = self.execute()
        self.messages.append({"role": "assistant", "content": result})
        return result

    def execute(self):
        response = client.chat.completions.create(
            model="openai/gpt-oss-120b",
            max_tokens=1000,
            messages=self.messages,
        ).choices[0].message.content
        return response

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

Your available actions are:

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

fish_weight:
e.g. fish_weight: Shark
returns weight of a fish when given the breed

Example session:

Question: How much does a shark weigh?
Thought: I should look the fish weight using fish_weight
Action: fish_weight: Shark
PAUSE

You will be called again with this:

Observation: A Great white shark weights 41000 lbs

You then output:

Answer: A Great white shark weights 41000 lbs
""".strip()

def calculate(expression):
    return eval(expression)

def fish_weight(name):
    if "Shark" in name:
        return("Great white shark weighs 41000 lbs")
    elif "Puffer" in name:
        return("A puffer fish weighs 20 lbs")
    else:
        return("A fish can weight upto 47000 lbs")

known_actions = {
    "calculate": calculate,
    "fish_weight": fish_weight
}

abot = Agent(prompt)

result = abot("How much does a Shark weigh?")
print(result)

result = fish_weight("Shark")
result

next_prompt = "Observation: {}".format(result)
abot(next_prompt)

abot.messages # View the list of messages containing the conversation

# Present a compund query
abot = Agent(prompt)
# New query
question = """I have 2 fishes, a Shark and a puffer fish. \
What is their combined weight"""
abot(question)

next_prompt = "Observation: {}".format(fish_weight("Shark"))
print(next_prompt)

abot(next_prompt)

next_prompt = "Observation: {}".format(fish_weight("Puffer fish"))
print(next_prompt)

abot(next_prompt)

next_prompt = "Observation: {}".format(eval("41000 + 20"))
print(next_prompt)

abot(next_prompt)

## Add loop (automate the reasoning + act process)

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

def query(question, max_turns=5):
    i = 0
    bot = Agent(prompt)
    next_prompt = question
    while i < max_turns:
        i += 1
        result = bot(next_prompt)
        print(result)
        actions = [
            action_re.match(a)
            for a in result.split('\n')
            if action_re.match(a)
        ]
        if actions:
            # There is an action to run
            action, action_input = actions[0].groups()
            if action not in known_actions:
                raise Exception("Unknown action: {}: {}".format(action, action_input))
            print(" -- running {} {}".format(action, action_input))
            observation = known_actions[action](action_input)
            print("Observation:", observation)
            next_prompt = "Observation: {}".format(observation)
        else:
            return

question = """I have 2 fishes, a Shark and a puffer fish. \
What is their combined weight"""
query(question)