Prompt template

In the previous section we learned that Chat models are finetuned on a specific syntax. Typically the APIs for these models will specify a way to use System, Human, and AI messages.

In this lesson we go through ChatPromptTemplate, the concept of Partial Prompts, Prompt Composition, debugging with Traces, and using Langchain Hub as a Prompt repository.

Please follow along in the interactive Code Sandbox.

Sandbox#

In this lesson we will learn about Prompts using a Code Sandbox. The Sandbox contains all of the example code for the lesson and helps you visualize the outputs it's a good idea to open it up in a new tab.

To follow along go to /src/prompts/index.ts. There is a default export that returns a Prompt Template and several examples commented out. Changing the default export will change the app accordingly.

<CodeSandboxEmbed src="//codesandbox.io/p/github/imjwang/prompt-sandbox/main?fontsize=14&hidenavigation=1&theme=dark&autoresize=1" style={{width: '100%', height: '600px'}} />

Partial prompts#

Currently, we are using Prompt Templates by sending an object to our Chain. There are times when we may want to control if and when to load certain variables. This can be done through "Partial Prompts".

To be exact we can make certain variables partial to create a Partial Prompt. Defining partial variables makes them optional when invoking the Chain. Thus we can omit them, load them in at different times, or provide a loader function.

Setup#

For this example we are using this template again.

xxxxxxxxxx

const template = `You are Spongebob Squarepants.

​

You are having a {mood} day and just got done with {activity}. Please keep the conversation short.

{currentMessage}

  `

partial#

You can add partial variables by using the partial method.

xxxxxxxxxx

  const promptTemplate = PromptTemplate.fromTemplate(template)

​

  const partialPrompt = await promptTemplate.partial({mood: "extremely frustrating"})

Loader functions#

You can tie the values to functions instead.

xxxxxxxxxx

  const activityLoader = () => {

    const getRandom = (array: Array<string>) => {

      return array[Math.floor(Math.random() * array.length)];

    }

    const activities = ["talking to squidward", "karate with sandy", "getting ripped off by mr. krabs"]

    const activity = getRandom(activities)

​

    return activity

  }

Like this.

xxxxxxxxxx

  const partialWithFunctionPrompt = await partialPrompt.partial({activity:  activityLoader})

Explicit use#

You can also define them explicitly in the constructor.

xxxxxxxxxx

  const partialTemplate = new PromptTemplate({

    inputVariables: ['mood', 'activity', 'currentMessage'],

    partialVariables: {

      mood: "extremely frustrating",

      activity: activityLoader,

    },

    template: template,

  })

With partial variables your Prompt Template handles loading variables on it's own. It can clean up code. And also enables control over when variables are loaded.

format results#

Now to use the prompt we only need to input one variable.

xxxxxxxxxx

  const prompt = await partialWithFunctionPrompt.format({currentMessage: "Hey boy sponge, how are you?"})

​

  console.log(prompt)

​

  /*

  You are Spongebob Squarepants.

​

  You are having a extremely frustrating day and just got done with talking to squidward. Please keep the conversation short.

  Hey boy sponge, how are you?

  */

Prompt composition#

Prompt Composition lets you insert a PromptTemplate in the place of a variable. This can be useful if you have a collection of Prompts that are well separated by logical concern. You can create an abstract Final PromptTemplate and fill in the slots to implement.

To use Composition you need to import PipelinePromptTemplate. In the example prompt we have a zero shot method that is known to improve reasoning. Perhaps we want to reserve part of the prompt to toggle between different reasoning prompts. In the diagram this is labeled as "slot". Maybe we have a collection of reasoning prompts in a repository somewhere that we can insert and test out. They may work differently and require different inputs. Some of them could be augmented by other systems like time.

Setup#

To implement this in Langchain we can modify the prompt from our last section. Instead of hard coding a command to be concise we change it to a {slot} variable.

xxxxxxxxxx

  const template = `You are Spongebob Squarepants.

​

'You are having a {mood} day and just got done with {activity}.'

​

{slot}

{currentMessage}

`

We create a finalPrompt. This is like a Template for Prompt Templates. We can give any of the variables such as {slot} it's own Prompt Template.

xxxxxxxxxx

  const fullPrompt = PromptTemplate.fromTemplate(template)

Zero shot prompt#

First create the zero shot prompt that we'll add to Composition. But let's alter "Let's think step by step" to accept a variable thoughtPolicy. This is simply used later to demonstrate how we can format the variable at the end of the Pipeline.

xxxxxxxxxx

  const zeroShotPrompt = PromptTemplate.fromTemplate(`Let's think {thoughtPolicy}.`)

PipelinePromptTemplate#

Now we are ready to use PipelinePromptTemplate. There are two options to note. finalPrompt is what we discussed earlier. It is a Prompt Template that recieves the other Prompt Templates. pipelinePrompts is an array of objects. Each object contains a PromptTemplate along with name which needs to be a {variable} in the finalPrompt. Any variables that are expanded into prompts will remain as normal variables.

xxxxxxxxxx

  const promptTemplate = new PipelinePromptTemplate({

    pipelinePrompts: [

      {

        name: "slot",

        prompt: zeroShotPrompt

      },

    ],

    finalPrompt: fullPrompt,

  })