Full documentation: aiconfig.lastmileai.dev

AIConfig saves prompts, models and model parameters as source control friendly configs. This allows you to iterate on prompts and model parameters separately from your application code.

1. Prompts as configs: a standardized JSON format to store generative AI model settings, prompt inputs/outputs, and flexible metadata.
2. Model-agnostic SDK: Python & Node SDKs to use aiconfig in your application code. AIConfig is designed to be model-agnostic and multi-modal, so you can extend it to work with any generative AI model, including text, image and audio.
3. AI Workbook editor: A notebook-like playground to edit aiconfig files visually, run prompts, tweak models and model settings, and chain things together.

Today, application code is tightly coupled with the gen AI settings for the application -- prompts, parameters, and model-specific logic is all jumbled in with app code.

• results in increased complexity
• makes it hard to iterate on the prompts or try different models easily
• makes it hard to evaluate prompt/model performance

AIConfig helps unwind complexity by separating prompts, model parameters, and model-specific logic from your application.

• simplifies application code -- simply call config.run()
• open the aiconfig in a playground to iterate quickly
• version control and evaluate the aiconfig - it's the AI artifact for your application.

• Getting Started
• Create an AIConfig
• Run a prompt
• Pass data into prompts
• Prompt Chains
• Callbacks and monitoring
• SDK Cheatsheet
• Cookbooks and guides
• CLI Chatbot
• RAG with AIConfig
• Prompt routing
• OpenAI function calling
• Chain of Verification
• Supported models
• LLaMA2 example
• Hugging Face (Mistral-7B) example
• PaLM
• Extensibility
• Contributing
• Roadmap
• FAQ

• Source-control friendly aiconfig format to save prompts and model settings, which you can use for evaluation, reproducibility and simplifying your application code.
• Multi-modal and model agnostic. Use with any model, and serialize/deserialize data with the same aiconfig format.
• Prompt chaining and parameterization with {{handlebars}} templating syntax, allowing you to pass dynamic data into prompts (as well as between prompts).
• Streaming supported out of the box, allowing you to get playground-like streaming wherever you use aiconfig.
• Notebook editor. AI Workbooks editor to visually create your aiconfig, and use the SDK to connect it to your application code.

Install with your favorite package manager for Node or Python.

npm install aiconfig

yarn add aiconfig

pip install python-aiconfig

poetry add python-aiconfig

Detailed installation instructions.

We cover Python instructions here, for Node.js please see the detailed Getting Started guide

In this quickstart, you will create a customizable NYC travel itinerary using aiconfig.

This AIConfig contains a prompt chain to get a list of travel activities from an LLM and then generate an itinerary in an order specified by the user.

Link to tutorial code: here

Note: Don't worry if you don't understand all the pieces of this yet, we'll go over it step by step.

{
  "name": "NYC Trip Planner",
  "description": "Intrepid explorer with ChatGPT and AIConfig",
  "schema_version": "latest",
  "metadata": {
    "models": {
      "gpt-3.5-turbo": {
        "model": "gpt-3.5-turbo",
        "top_p": 1,
        "temperature": 1
      },
      "gpt-4": {
        "model": "gpt-4",
        "max_tokens": 3000,
        "system_prompt": "You are an expert travel coordinator with exquisite taste."
      }
    },
    "default_model": "gpt-3.5-turbo"
  },
  "prompts": [
    {
      "name": "get_activities",
      "input": "Tell me 10 fun attractions to do in NYC."
    },
    {
      "name": "gen_itinerary",
      "input": "Generate an itinerary ordered by {{order_by}} for these activities: {{get_activities.output}}.",
      "metadata": {
        "model": "gpt-4",
        "parameters": {
          "order_by": "geographic location"
        }
      }
    }
  ]
}

Note: Make sure to specify the API keys (such as OPENAI_API_KEY) in your environment before proceeding.

export OPENAI_API_KEY=my_key

You don't need to worry about how to run inference for the model; it's all handled by AIConfig. The prompt runs with gpt-3.5-turbo since that is the default_model for this AIConfig.

import asyncio
from aiconfig import AIConfigRuntime, InferenceOptions

async def main():
  # Load the aiconfig
  config = AIConfigRuntime.load('travel.aiconfig.json')

  # Run a single prompt (with streaming)
  inference_options = InferenceOptions(stream=True)
  await config.run("get_activities", options=inference_options)

asyncio.run(main())

This prompt depends on the output of get_activities. It also takes in parameters (user input) to determine the customized itinerary.

Let's take a closer look:

gen_itinerary prompt:

"Generate an itinerary ordered by {{order_by}} for these activities: {{get_activities.output}}."

prompt metadata:

{
  "metadata": {
    "model": "gpt-4",
    "parameters": {
      "order_by": "geographic location"
    }
  }
}

Observe the following:

1. The prompt depends on the output of the get_activities prompt.
2. It also depends on an order_by parameter (using {{handlebars}} syntax)
3. It uses gpt-4, whereas the get_activities prompt it depends on uses gpt-3.5-turbo.

Effectively, this is a prompt chain between gen_itinerary and get_activities prompts, as well as as a model chain between gpt-3.5-turbo and gpt-4.

Let's run this with AIConfig:

Replace config.run above with this:

await config.run("gen_itinerary", params={"order_by": "duration"}, options=inference_options, run_with_dependencies=True)

Notice how simple the syntax is to perform a fairly complex task - running 2 different prompts across 2 different models and chaining one's output as part of the input of another.

The code will just run get_activities, then pipe its output as an input to gen_itinerary, and finally run gen_itinerary.

Let's save the AIConfig back to disk, and serialize the outputs from the latest inference run as well:

# Save the aiconfig to disk. and serialize outputs from the model run
config.save('updated.aiconfig.json', include_outputs=True)

We can iterate on an aiconfig using a notebook-like editor called an AI Workbook. Now that we have an aiconfig file artifact that encapsulates the generative AI part of our application, we can iterate on it separately from the application code that uses it.

1. Go to https://lastmileai.dev.
2. Go to Workbooks page: https://lastmileai.dev/workbooks
3. Click dropdown from ' New Workbook' and select 'Create from AIConfig'
4. Upload travel.aiconfig.json

Try out the workbook playground here: NYC Travel Workbook

We are working on a local editor that you can run yourself. For now, please use the hosted version on https://lastmileai.dev.

There is a lot you can do with aiconfig. We have several other tutorials to help get you started:

• Create an AIConfig from scratch
• Run a prompt
• Pass data into prompts
• Prompt chains
• Callbacks and monitoring

Here are some example uses:

• CLI Chatbot
• RAG with AIConfig
• Prompt routing
• OpenAI function calling
• Chain of thought

If you are already using OpenAI completion API's in your application, you can get started very quickly to start saving the messages in an aiconfig.

Usage: see openai_wrapper.ipynb.

Now you can continue using openai completion API as normal. When you want to save the config, just call new_config.save() and all your openai completion calls will get serialized to disk.

Detailed guide here

AIConfig supports the following model models out of the box:

• OpenAI chat models (GPT-3, GPT-3.5, GPT-4)
• LLaMA2 (running locally)
• Google PaLM models (PaLM chat)
• Hugging Face text generation models (e.g. Mistral-7B)

• OpenAI
• LLaMA example
• Hugging Face (Mistral-7B) example
• PaLM

If you need to use a model that isn't provided out of the box, you can implement a ModelParser for it (see Extending AIConfig). We welcome contributions

AIConfig specification

Read the Usage Guide for more details.

The AIConfig SDK supports CRUD operations for prompts, models, parameters and metadata. Here are some common examples.

The root interface is the AIConfigRuntime object. That is the entrypoint for interacting with an AIConfig programmatically.

Let's go over a few key CRUD operations to give a glimpse.

config = AIConfigRuntime.create("aiconfig name", "description")

resolve deserializes an existing Prompt into the data object that its model expects.

config.resolve("prompt_name", params)

params are overrides you can specify to resolve any {{handlebars}} templates in the prompt. See the gen_itinerary prompt in the Getting Started example.

serialize is the inverse of resolve -- it serializes the data object that a model understands into a Prompt object that can be serialized into the aiconfig format.

config.serialize("model_name", data, "prompt_name")

run is used to run inference for the specified Prompt.

config.run("prompt_name", params)

This is a variant of run -- this re-runs all prompt dependencies. For example, in travel.aiconfig.json, the gen_itinerary prompt references the output of the get_activities prompt using {{get_activities.output}}.

Running this function will first execute get_activities, and use its output to resolve the gen_itinerary prompt before executing it. This is transitive, so it computes the Directed Acyclic Graph of dependencies to execute. Complex relationships can be modeled this way.

config.run_with_dependencies("gen_itinerary")

Use the get/set_metadata and get/set_parameter methods to interact with metadata and parameters (set_parameter is just syntactic sugar to update "metadata.parameters")

config.set_metadata("key", data, "prompt_name")

Note: if "prompt_name" is specified, the metadata is updated specifically for that prompt. Otherwise, the global metadata is updated.

Use the AIConfigRuntime.register_model_parser if you want to use a different ModelParser, or configure AIConfig to work with an additional model.

AIConfig uses the model name string to retrieve the right ModelParser for a given Prompt (see AIConfigRuntime.get_model_parser), so you can register a different ModelParser for the same ID to override which ModelParser handles a Prompt.

For example, suppose I want to use MyOpenAIModelParser to handle gpt-4 prompts. I can do the following at the start of my application:

AIConfigRuntime.register_model_parser(myModelParserInstance, ["gpt-4"])

Use callback events to trace and monitor what's going on -- helpful for debugging and observability.

from aiconfig import AIConfigRuntime, CallbackEvent, CallbackManager
config = AIConfigRuntime.load('aiconfig.json')

async def my_custom_callback(event: CallbackEvent) -> None:
  print(f"Event triggered: {event.name}", event)

callback_manager = CallbackManager([my_custom_callback])
config.set_callback_manager(callback_manager)

await config.run("prompt_name")

Read more here

AIConfig is designed to be customized and extended for your use-case. The Extensibility guide goes into more detail.

Currently, there are 3 core ways to extend AIConfig:

1. Supporting other models - define a ModelParser extension
2. Callback event handlers - tracing and monitoring
3. Custom metadata - save custom fields in aiconfig

This is our first open-source project and we'd love your help.

See our contributing guidelines -- we would especially love help adding support for additional models that the community wants.

We provide several guides to demonstrate the power of aiconfig.

See the cookbooks folder for examples to clone.

• Wizard GPT - speak to a wizard on your CLI

• CLI-mate - help you make code-mods interactively on your codebase.

• RAG with AIConfig

At its core, RAG is about passing data into prompts. Read how to pass data with AIConfig.

• OpenAI function calling

• Prompt routing

A variant of chain-of-thought is Chain of Verification, used to help reduce hallucinations. Check out the aiconfig cookbook for CoVe:

• Chain of Verification

• LLaMA example

• Hugging Face (Mistral-7B) example

• PaLM

This project is under active development.

If you'd like to help, please see the contributing guidelines.

Please create issues for additional capabilities you'd like to see.

Here's what's already on our roadmap:

• Evaluation interfaces: allow aiconfig artifacts to be evaluated with user-defined eval functions.
  • We are also considering integrating with existing evaluation frameworks.
• Local editor for aiconfig: enable you to interact with aiconfigs more intuitively.
• OpenAI Assistants API support
• Multi-modal ModelParsers:
  • GPT4-V support
  • DALLE-3
  • Whisper
  • HuggingFace image generation

Editing a configshould be done either programmatically via SDK or via the UI (workbooks):

• Programmatic editing.

• Edit with a workbook editor: this is similar to editing an ipynb file as a notebook (most people never touch the json ipynb directly)

You should only edit the aiconfig by hand for minor modifications, like tweaking a prompt string or updating some metadata.

Out of the box, AIConfig already supports all OpenAI GPT* models, Google’s PaLM model and any “textgeneration” model on Hugging Face (like Mistral). See Supported Models for more details.

Additionally, you can install aiconfig extensions for additional models (see question below).

Yes. This example goes through how to do it.

We are also working on adding support for the Assistants API.

Model support is implemented as “ModelParser”s in the AIConfig SDK, and the idea is that anyone, including you, can define a ModelParser (and even publish it as an extension package).

All that’s needed to use a model with AIConfig is a ModelParser that knows

• how to serialize data from a model into the aiconfig format
• how to deserialize data from an aiconfig into the type the model expects
• how to run inference for model.

For more details, see Extensibility.

The AIConfigRuntime object is used to interact with an aiconfig programmatically (see SDK usage guide). As you run prompts, this object keeps track of the outputs returned from the model.

You can choose to serialize these outputs back into the aiconfig by using the config.save(include_outputs=True) API. This can be useful for preserving context -- think of it like session state.

For example, you can use aiconfig to create a chatbot, and use the same format to save the chat history so it can be resumed for the next session.

You can also choose to save outputs to a different file than the original config -- config.save("history.aiconfig.json", include_outputs=True).

It helps to have a standardized format specifically for storing generative AI prompts, inference results, model parameters and arbitrary metadata, as opposed to a general-purpose configuration schema.

With that standardization, you just need a layer that knows how to serialize/deserialize from that format into whatever the inference endpoints require.

We believe that notebooks are a perfect iteration environment for generative AI -- they are flexible, multi-modal, and collaborative.

The multi-modality and flexibility offered by notebooks and ipynb offers a good interaction model for generative AI. The aiconfig file format is extensible like ipynb, and AI Workbook editor allows rapid iteration in a notebook-like IDE.

AI Workbooks are to AIConfig what Jupyter notebooks are to ipynb

There are 2 areas where we are going beyond what notebooks offer:

1. aiconfig is more source-control friendly than ipynb. ipynb stores binary data (images, etc.) by encoding it in the file, while aiconfig recommends using file URI references instead.
2. aiconfig can be imported and connected to application code using the AIConfig SDK.