Introducing OrchestrAI: Building Custom Autonomous Agents with Prompt Chaining

pipeline: 
  - module: start_module
    inputs: []
    output_name: request
  - module: task_planner
    inputs: [request]
    output_name: task_plan
  - module: scrutinizer
    model_config:
      model: 'gpt-3.5-turbo'
      temperature: 0.7
    inputs: [request, task_plan]
    output_name: scrutinized_task_plan
  - module: enhancer
    inputs: [request, scrutinized_task_plan, task_plan]
    output_name: enhanced_task_plan
  - module: markdown_converter
    model_config:
      model: 'gpt-3.5-turbo'
      temperature: 0.3
    inputs: [enhanced_task_plan]
    output_name: markdown_plan

pipeline: 
  - module: start_module
    inputs: []
    output_name: request
  - module: translator
    model_config:
      model: 'gpt-3.5-turbo'
      temperature: 0.2
    inputs: [request]
    supplement: "Spanish"
    output_name: translation

def chameleon(prompt, module_name, model_config=None):
    ai = AI(module_name, model_config=model_config)
    response = ai.generate_response(prompt)
    log_action({"module": module_name, "input": prompt, "output": response})
    return response["response_text"]

pipeline: 
  - module: start_module
    inputs: []
    output_name: request
  - module: code_planner
    inputs: [request]
    output_name: code_plan
  - module: engineer
    inputs: [request, code_plan]
    output_name: code
  - module: debugger
    model_config:
      model: 'gpt-3.5-turbo-16k'
      temperature: 0.7
    inputs: [request, code]
    output_name: working_codebase
  - module: modify_codebase
    inputs: [working_codebase]
    output_name: modified_codebase
  - module: create_readme
    inputs: [modified_codebase]
    output_name: readme

You can use tools. Tools are functions you can use via tag activation only.
Tool use is first person, "I will use..."
You can use multiple tools, the order of the tools is the order they are executed in.
Activate a tool with the tag wrapped around a JSON object. It must be perfect JSON for the regex to work.
<@ { "tool_name": "TOOL_NAME_HERE", "tool_input_1" : "etc" } @>

GENERATE_IMAGE - Used to generate an image from a text prompt - Images are stored on generated_outputs/generated_images/{choose}.png
<@ { "tool_name": "GENERATE_IMAGE", "filename": choose , "prompt" : "Descriptive image prompt" } @>

pipeline: 
  - module: start_module
    inputs: []
    output_name: request
  - module: storyteller
    inputs: [request]
    output_name: story
  - module: illustrator
    inputs: [request, story]
    output_name: illustration

if wandb_enabled:
    globals.agent_start_time_ms = round(datetime.datetime.now().timestamp() * 1000) 

    # create a root span for the agent.
    root_span = Trace(
        name="Agent",
        kind="agent",
        start_time_ms=globals.agent_start_time_ms,
        end_time_ms=globals.agent_start_time_ms,
        metadata={"pipeline_name": pipeline_name},
    )

    # the agent calls into a pipeline, so we create a chain span.
    globals.chain_span = Trace(
        name=pipeline_name,
        kind="chain",
        start_time_ms=globals.agent_start_time_ms,
        end_time_ms=globals.agent_start_time_ms,
    )

    root_span.add_child(globals.chain_span) # add the chain span as a child of the root span

if wandb_enabled:
        wb.wandb_log_llm(response, ai.model, ai.temperature, parent = globals.chain_span)

def wandb_log_llm(data, model, temperature, parent):
    
    runtime = data["llm_end_time_ms"] - data["llm_start_time_ms"]


    llm_span = Trace(
        name=data["module_name"],
        kind="llm",
        status_code=data["status_code"],
        status_message=data["status_message"],
        metadata={
            "temperature": temperature,
            "token_usage": {"total_tokens": data["token_count"]},
            "runtime_ms": runtime,
            "module_name": data["module_name"],
            "model_name": model,
            "max_tokens": data["max_tokens"],
            "top_p": data["top_p"],
            "frequency_penalty": data["frequency_penalty"],
            "presence_penalty": data["presence_penalty"]
        },
        start_time_ms=parent._span.end_time_ms,
        end_time_ms=data["llm_end_time_ms"],
        inputs={"system_prompt": data["system_prompt"], "query": data["prompt"]},
        outputs={"response": data["response_text"]}
    )
    
    parent.add_child(llm_span)

    parent.add_inputs_and_outputs(
        inputs={"query": data["prompt"]},
        outputs={"response": data["response_text"]}
    )
    parent._span.end_time_ms = data["llm_end_time_ms"]

    llm_span.log(name="pipeline_trace")