Migrate an existing prompt

You already have a prompt. It’s just living in your application code: an inline messages array, a system string, a ChatPromptTemplate, a PromptTemplate. Migrating it to AgentMark means moving that text into a versioned .prompt.mdx and loading it at the call site, so the prompt is editable, type-safe, and traceable instead of hard-coded.

The pattern

It’s the same three moves regardless of which SDK or framework the prompt currently lives in:

Extract the prompt into agentmark/<name>.prompt.mdx. The system / user / assistant turns become message tags, and the template variables become {props.*}. See Creating prompts for the shape.
Load + render it at the call site: client.loadTextPrompt(...) then prompt.format({ props }) gives you back messages (and text_config).
Keep your model call. You are replacing where the prompt comes from, not your SDK. Feed the rendered messages to whatever you already call (generateText, openai.chat.completions.create, model.invoke, …), then delete the inline prompt.

The prompt file is the same in every case. For the examples below:

agentmark/summarize.prompt.mdx

---
name: summarize
text_config:
  model_name: openai/gpt-4o-mini
---

<System>You are a concise summarizer. Reply with a single sentence, no preamble.</System>
<User>Summarize this article:

{props.article}</User>

Raw OpenAI / Anthropic SDK

An inline messages array (or system + messages) moves straight into the prompt file; the create call stays.

import OpenAI from "openai";
const openai = new OpenAI();

export async function summarize(article: string) {
  const res = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [
      { role: "system", content: "You are a concise summarizer. Reply with a single sentence, no preamble." },
      { role: "user", content: `Summarize this article:\n\n${article}` },
    ],
  });
  return res.choices[0]?.message?.content ?? "";
}

import OpenAI from "openai";
import { client } from "./agentmark.client";
const openai = new OpenAI();

export async function summarize(article: string) {
  const prompt = await client.loadTextPrompt("summarize.prompt.mdx");
  const { messages, text_config } = await prompt.format({ props: { article } });

  const res = await openai.chat.completions.create({
    model: text_config.model_name.replace(/^openai\//, ""),
    // Cast the neutral messages to OpenAI's param type. Structurally
    // compatible, but TypeScript won't infer it, so the call needs the cast.
    messages: messages as OpenAI.Chat.ChatCompletionMessageParam[],
  });
  return res.choices[0]?.message?.content ?? "";
}

The Anthropic SDK is the same idea: load + format, then pass messages (and split the system turn out as Anthropic requires) to anthropic.messages.create.

Vercel AI SDK

generateText’s system + prompt/messages come from the rendered prompt; the generateText call stays.

import { generateText } from "ai";
import { openai } from "@ai-sdk/openai";

export async function reply(question: string) {
  const { text } = await generateText({
    model: openai("gpt-4o-mini"),
    system: "You are a friendly support agent. Answer in two sentences or fewer.",
    prompt: question,
  });
  return text;
}

import { generateText } from "ai";
import { openai } from "@ai-sdk/openai";
import { client } from "./agentmark.client";

export async function reply(question: string) {
  const prompt = await client.loadTextPrompt("reply.prompt.mdx");
  const { messages, text_config } = await prompt.format({ props: { question } });

  const { text } = await generateText({
    model: openai(text_config.model_name.replace(/^openai\//, "")),
    messages,
  });
  return text;
}

LangChain

A ChatPromptTemplate is a prompt, so migrate it. The template’s messages move into the .prompt.mdx; you drop the ChatPromptTemplate + .pipe() and keep the chat model, because LangChain chat models accept a message array directly.

import { ChatPromptTemplate } from "@langchain/core/prompts";
import { ChatOpenAI } from "@langchain/openai";

const prompt = ChatPromptTemplate.fromMessages([
  ["system", "You extract structured fields. Return JSON with keys: name, date, amount."],
  ["human", "{document}"],
]);
const model = new ChatOpenAI({ model: "gpt-4o-mini" });

export async function extract(document: string) {
  const chain = prompt.pipe(model);
  const res = await chain.invoke({ document });
  return typeof res.content === "string" ? res.content : JSON.stringify(res.content);
}

import { ChatOpenAI } from "@langchain/openai";
import { client } from "./agentmark.client";

const model = new ChatOpenAI({ model: "gpt-4o-mini" });

export async function extract(document: string) {
  const prompt = await client.loadTextPrompt("extract.prompt.mdx");
  const { messages } = await prompt.format({ props: { document } });

  const res = await model.invoke(messages);
  return typeof res.content === "string" ? res.content : JSON.stringify(res.content);
}

LlamaIndex (Python)

A PromptTemplate (or ChatPromptTemplate) moves into the .prompt.mdx; you render with AgentMark and call the LLM with the resulting messages.

from llama_index.core import PromptTemplate
from llama_index.llms.openai import OpenAI

tmpl = PromptTemplate(
    "You extract structured fields. Return JSON with keys: name, date, amount.\n\n{document}"
)
llm = OpenAI(model="gpt-4o-mini")

def extract(document: str) -> str:
    return llm.complete(tmpl.format(document=document)).text

from llama_index.llms.openai import OpenAI
from agentmark_client import client

llm = OpenAI(model="gpt-4o-mini")

async def extract(document: str) -> str:
    prompt = await client.load_text_prompt("extract.prompt.mdx")
    formatted = await prompt.format(props={"document": document})
    res = llm.chat(formatted.messages)
    return res.message.content

After you migrate

Your model call doesn’t change: same SDK, same function signature, same behavior. All that moved is where the prompt comes from: editing the prompt is now a versioned, reviewable .prompt.mdx change instead of a code edit, and every run is traceable. Run agentmark doctor to confirm the prompt parses, then run it to confirm the call site still works.

Have questions?

Reach out any time:

Email the team at hello@agentmark.co for support
Schedule an Enterprise Demo to learn about AgentMark’s business solutions

Get started

Coding agents

Concepts

Build prompts

Evaluate

Observe

Deploy

Account & billing

Integrations

Reference

Migrate an existing prompt

The pattern

Raw OpenAI / Anthropic SDK

Vercel AI SDK

LangChain

LlamaIndex (Python)

After you migrate

Have questions?

​The pattern

​Raw OpenAI / Anthropic SDK

​Vercel AI SDK

​LangChain

​LlamaIndex (Python)

​After you migrate

​Have questions?

The pattern

Raw OpenAI / Anthropic SDK

Vercel AI SDK

LangChain

LlamaIndex (Python)

After you migrate

Have questions?