프롬프트 가져오기

프롬프트 가져오기 (Pull Prompts)

LLM 앱에서 프롬프트를 어떻게 테스트하고 사용하는지 배워볼게요. Confident AI에서 프롬프트 버전을 데이터셋을 가져오듯이 가져올 수 있어요. 가져온 뒤에는 코드에서 변수를 보간(interpolate)해 실제 LLM 호출에 사용하게 돼요. 프롬프트는 필요할 때마다 가져오지 말고 한 번 가져와 메모리에 저장해 두는 걸 권장해요.

출처: 문서

본문

개요

Confident AI에서 프롬프트 버전을 데이터셋을 가져오듯이 가져올 수 있어요. 동작 방식은:

• Confident AI에 가져오려는 프롬프트의 alias와 선택적으로 version을 제공
• Confident AI가 보간되지 않은(non-interpolated) 프롬프트 버전을 제공
• 코드에서 변수를 보간

프롬프트는 필요할 때마다 가져오기보다 한 번 가져와 메모리에 저장해 두는 게 좋아요.

Confident AI는 Git과 비슷한 프롬프트 버전 관리 시스템을 사용해요.

• 프롬프트의 각 새 반복은 새 커밋(commit)으로 저장돼요. 플랫폼에서 직접 또는 deepeval Python/TypeScript SDK의 push 메서드로 커밋을 만들 수 있어요.
• 어떤 커밋이든 버전(version)으로 승격(promote)할 수 있어요. 버전은 공식 체크포인트 역할을 하며, 안정적이거나 프로덕션 준비가 된 프롬프트를 추적하기 쉬워요.
• 버전 위에 라벨(label)을 붙일 수도 있어요. 라벨은 버전에 명확하고 사람 친화적인 식별자를 주어 빠르게 참조할 수 있게 해줘요(예: "production" 또는 "v1.2-stable").

버전으로 프롬프트 가져오기 (Pull Prompt By Version)

alias로 프롬프트 가져오기

정의한 alias를 제공해 프롬프트 버전을 가져와요:

Python

from deepeval.prompt import Prompt

prompt = Prompt(alias="YOUR-PROMPT-ALIAS")
prompt.pull(version="latest")

latest를 특정 버전 대신 전달하면 Confident AI가 프롬프트의 가장 최근 버전을 반환해요. 하지만 version을 지정해 이 동작을 재정의할 수도 있어요.

prompt.pull(version="00.00.01")

TypeScript

import { Prompt } from "deepeval";

const prompt = new Prompt({ alias: "YOUR-PROMPT-ALIAS" });
await prompt.pull({ version: "latest" });

latest를 특정 버전 대신 전달하면 Confident AI가 프롬프트의 가장 최근 버전을 반환해요. 하지만 version을 지정해 이 동작을 재정의할 수도 있어요.

await prompt.pull({ version: "00.00.01" });

curl

Request (GET /v1/prompts/{alias}/versions/{version}) — API reference

curl -X GET "https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}" \
  -H "CONFIDENT_API_KEY: <PROJECT-API-KEY>"

import requests

response = requests.get(
    "https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}",
    headers={
        "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
    },
)

print(response.json())

const response = await fetch("https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}", {
  method: "GET",
  headers: {
    "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
  },
});

const data = await response.json();
console.log(data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}"))
            .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
            .GET()
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let response = reqwest::Client::new()
        .get("https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}")
        .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
        .send()
        .await?;

    println!("{}", response.text().await?);

    Ok(())
}

변수 보간 (Interpolate variables)

이제 프롬프트 템플릿이 있으니, 프롬프트 버전에 정의한 동적 변수를 보간해요.

Python

interpolated_prompt = prompt.interpolate(name="Joe")

TypeScript

const interpolatedPrompt = prompt.interpolate({ name: "Joe" });

curl

# Interpolation is done client-side after pulling the prompt
# The API response includes an "interpolationType" field indicating the format:
# - "FSTRING": Use {{ variable }} format (default)
# - "HANDLEBARS": Use {{variable}} format
# Replace variables manually based on the interpolationType in your application code

예를 들어 프롬프트 버전이 이렇다면:

Messages

{
  "role": "system",
  "content": "You are a helpful assistant called {{ name }}. Speak normally like a human."
}

보간 타입이 {{ variable }}이고 이름(예: "Joe")을 보간하면 바로 사용할 수 있는 이 프롬프트가 됩니다:

{
  "role": "system",
  "content": "You are a helpful assistant called Joe. Speak normally like a human."
}

Text

You are a helpful assistant called {{ name }}. Speak normally like a human.

보간 타입이 {{ variable }}이고 이름(예: "Joe")을 보간하면 바로 사용할 수 있는 이 프롬프트가 됩니다:

You are a helpful assistant called Joe. Speak normally like a human.

Python

interpolated_prompt = prompt.interpolate(name="Joe")

TypeScript

const interpolatedPrompt = prompt.interpolate({ name: "Joe" });

curl

# Interpolation is done client-side after pulling the prompt
# The API response includes an "interpolationType" field indicating the format:
# - "FSTRING": Use {{ variable }} format (default)
# - "HANDLEBARS": Use {{variable}} format
# Replace variables manually based on the interpolationType in your application code

변수가 없다면, LLM 애플리케이션에서 사용할 프롬프트 템플릿의 사본을 만들기 위해 그래도 interpolate() 메서드를 사용해야 해요.

보간된 프롬프트 사용

이제 보간된 프롬프트 버전이 있어요. 예를 들어:

Messages

{
  "role": "system",
  "content": "You are a helpful assistant called Joe. Speak normally like a human."
}

이것을 사용해 선택한 LLM 프로바이더에서 텍스트를 생성할 수 있어요. OpenAI 예시는 다음과 같아요:

Python

from deepeval.prompt import Prompt
from openai import OpenAI

prompt = Prompt(alias="YOUR-PROMPT-ALIAS")
prompt.pull()
interpolated_prompt = prompt.interpolate() # interpolate prompt

response = OpenAI().chat.completions.create(
    model="gpt-4o-mini",
    messages=interpolated_prompt
)

print(response.choices[0].message.content)

TypeScript

import { Prompt } from "deepeval";
import { OpenAI } from "openai";

const prompt = new Prompt({ alias: "YOUR-PROMPT-ALIAS" });
await prompt.pull();
const interpolatedPrompt = prompt.interpolate(); // interpolate prompt

const openai = new OpenAI();
const response = await openai.chat.completions.create({
  model: "gpt-4o",
  messages: interpolatedPrompt as any[],
});

console.log(response.choices[0].message.content);

curl

먼저 Confident AI에서 프롬프트를 가져와요:

Request (GET /v1/prompts) — API reference

curl -X GET "https://api.confident-ai.com/v1/prompts" \
  -H "CONFIDENT_API_KEY: <PROJECT-API-KEY>"

import requests

response = requests.get(
    "https://api.confident-ai.com/v1/prompts",
    headers={
        "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
    },
)

print(response.json())

const response = await fetch("https://api.confident-ai.com/v1/prompts", {
  method: "GET",
  headers: {
    "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
  },
});

const data = await response.json();
console.log(data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.confident-ai.com/v1/prompts", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.confident-ai.com/v1/prompts"))
            .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
            .GET()
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let response = reqwest::Client::new()
        .get("https://api.confident-ai.com/v1/prompts")
        .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
        .send()
        .await?;

    println!("{}", response.text().await?);

    Ok(())
}

그런 다음 변수를 보간하고 보간된 프롬프트를 OpenAI로 사용해요:

curl -X POST "https://api.openai.com/v1/chat/completions" \
  -H "Authorization: Bearer YOUR_O..._KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4.1",
    "messages": <YOUR-INTERPOLATED-PROMPT>
  }'

Text

You are a helpful assistant called Joe. Speak normally like a human.

이것을 사용해 선택한 LLM 프로바이더에서 텍스트를 생성할 수 있어요. OpenAI 예시는 다음과 같아요:

Python

from deepeval.prompt import Prompt
from openai import OpenAI

prompt = Prompt(alias="YOUR-PROMPT-ALIAS")
prompt.pull()
interpolated_prompt = prompt.interpolate() # interpolate prompt

response = OpenAI().chat.completions.create(
    model="gpt-4o-mini",
    messages={"role": "system", "content": interpolated_prompt}
)

print(response.choices[0].message.content)

TypeScript

import { Prompt } from "deepeval";
import { OpenAI } from "openai";

const prompt = new Prompt({ alias: "YOUR-PROMPT-ALIAS" });
await prompt.pull();
const interpolatedPrompt = prompt.interpolate(); // interpolate prompt

const openai = new OpenAI();
const response = await openai.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "system", content: interpolatedPrompt }],
});

console.log(response.choices[0].message.content);

curl

먼저 Confident AI에서 프롬프트를 가져와요:

Request (GET /v1/prompts) — API reference

curl -X GET "https://api.confident-ai.com/v1/prompts" \
  -H "CONFIDENT_API_KEY: <PROJECT-API-KEY>"

import requests

response = requests.get(
    "https://api.confident-ai.com/v1/prompts",
    headers={
        "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
    },
)

print(response.json())

const response = await fetch("https://api.confident-ai.com/v1/prompts", {
  method: "GET",
  headers: {
    "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
  },
});

const data = await response.json();
console.log(data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.confident-ai.com/v1/prompts", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.confident-ai.com/v1/prompts"))
            .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
            .GET()
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let response = reqwest::Client::new()
        .get("https://api.confident-ai.com/v1/prompts")
        .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
        .send()
        .await?;

    println!("{}", response.text().await?);

    Ok(())
}

그런 다음 변수를 보간하고 보간된 프롬프트를 OpenAI로 사용해요:

curl -X POST "https://api.openai.com/v1/chat/completions" \
  -H "Authorization: Bearer YOUR_O..._KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4.1",
    "messages": <YOUR-INTERPOLATED-PROMPT>
  }'

프롬프트와 연관된 모든 버전을 가져올 수도 있어요:

Python

from deepeval.prompt import Prompt

prompt = Prompt(alias="YOUR-PROMPT-ALIAS")
commits = prompt._get_versions()

Typescript

import { Prompt } from "deepeval";

const prompt = new Prompt({ alias: "YOUR-PROMPT-ALIAS" });
const commits = await prompt.getVersions();

curl

Request (GET /v1/prompts/{alias}/versions) — API reference

curl -X GET "https://api.confident-ai.com/v1/prompts/{alias}/versions" \
  -H "CONFIDENT_API_KEY: <PROJECT-API-KEY>"

import requests

response = requests.get(
    "https://api.confident-ai.com/v1/prompts/{alias}/versions",
    headers={
        "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
    },
)

print(response.json())

const response = await fetch("https://api.confident-ai.com/v1/prompts/{alias}/versions", {
  method: "GET",
  headers: {
    "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
  },
});

const data = await response.json();
console.log(data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.confident-ai.com/v1/prompts/{alias}/versions", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.confident-ai.com/v1/prompts/{alias}/versions"))
            .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
            .GET()
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let response = reqwest::Client::new()
        .get("https://api.confident-ai.com/v1/prompts/{alias}/versions")
        .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
        .send()
        .await?;

    println!("{}", response.text().await?);

    Ok(())
}

라벨로 프롬프트 가져오기 (Pull Prompts By Label)

플랫폼에서 버전에 붙인 label을 사용해 특정 프롬프트 버전을 가져올 수도 있어요.

Python

from deepeval.prompt import Prompt

prompt = Prompt(alias="YOUR-PROMPT-ALIAS")
prompt.pull(label="staging")

TypeScript

import { Prompt } from "deepeval";

const prompt = new Prompt({ alias: "YOUR-PROMPT-ALIAS" });
await prompt.pull({ label: "staging" });

curl

Request (GET /v1/prompts/{alias}/labels/{label}) — API reference

curl -X GET "https://api.confident-ai.com/v1/prompts/{alias}/labels/{label}" \
  -H "CONFIDENT_API_KEY: <PROJECT-API-KEY>"

import requests

response = requests.get(
    "https://api.confident-ai.com/v1/prompts/{alias}/labels/{label}",
    headers={
        "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
    },
)

print(response.json())

const response = await fetch("https://api.confident-ai.com/v1/prompts/{alias}/labels/{label}", {
  method: "GET",
  headers: {
    "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
  },
});

const data = await response.json();
console.log(data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.confident-ai.com/v1/prompts/{alias}/labels/{label}", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.confident-ai.com/v1/prompts/{alias}/labels/{label}"))
            .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
            .GET()
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let response = reqwest::Client::new()
        .get("https://api.confident-ai.com/v1/prompts/{alias}/labels/{label}")
        .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
        .send()
        .await?;

    println!("{}", response.text().await?);

    Ok(())
}

가져오기 전에 각 프롬프트 버전에 라벨을 수동으로 붙여야 해요. 하는 방법은 여기를 클릭하세요.

라벨로 가져오면, 충분한 권한이 있는 사용자가 코드를 거치지 않고도 프롬프트의 새 버전을 "배포"할 수 있게 됩니다.

커밋으로 프롬프트 가져오기 (Pull Prompts By Commit)

alias와 커밋 hash를 사용해 프롬프트의 특정 스냅샷을 가져올 수도 있어요.

Python

from deepeval.prompt import Prompt

prompt = Prompt(alias="YOUR-PROMPT-ALIAS")
prompt.pull()

기본적으로 Confident AI는 프롬프트의 가장 최근 커밋을 반환해요. 하지만 hash를 지정해 이 동작을 재정의할 수도 있어요.

prompt.pull(hash="bab04ce")

TypeScript

import { Prompt } from "deepeval";

const prompt = new Prompt({ alias: "YOUR-PROMPT-ALIAS" });
await prompt.pull();

기본적으로 Confident AI는 프롬프트의 가장 최근 커밋을 반환해요. 하지만 hash를 지정해 이 동작을 재정의할 수도 있어요.

await prompt.pull({ hash: "bab04ce" });

curl

Request (GET /v1/prompts/{alias}/commits/{hash}) — API reference

curl -X GET "https://api.confident-ai.com/v1/prompts/{alias}/commits/{hash}" \
  -H "CONFIDENT_API_KEY: <PROJECT-API-KEY>"

import requests

response = requests.get(
    "https://api.confident-ai.com/v1/prompts/{alias}/commits/{hash}",
    headers={
        "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
    },
)

print(response.json())

const response = await fetch("https://api.confident-ai.com/v1/prompts/{alias}/commits/{hash}", {
  method: "GET",
  headers: {
    "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
  },
});

const data = await response.json();
console.log(data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.confident-ai.com/v1/prompts/{alias}/commits/{hash}", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.confident-ai.com/v1/prompts/{alias}/commits/{hash}"))
            .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
            .GET()
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let response = reqwest::Client::new()
        .get("https://api.confident-ai.com/v1/prompts/{alias}/commits/{hash}")
        .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
        .send()
        .await?;

    println!("{}", response.text().await?);

    Ok(())
}

프롬프트와 연관된 모든 커밋을 가져올 수도 있어요:

Python

from deepeval.prompt import Prompt

prompt = Prompt(alias="YOUR-PROMPT-ALIAS")
commits = prompt._get_commits()

Typescript

import { Prompt } from "deepeval";

const prompt = new Prompt({ alias: "YOUR-PROMPT-ALIAS" });
const commits = await prompt.getCommits();

curl

Request (GET /v1/prompts/{alias}/commits) — API reference

curl -X GET "https://api.confident-ai.com/v1/prompts/{alias}/commits" \
  -H "CONFIDENT_API_KEY: <PROJECT-API-KEY>"

import requests

response = requests.get(
    "https://api.confident-ai.com/v1/prompts/{alias}/commits",
    headers={
        "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
    },
)

print(response.json())

const response = await fetch("https://api.confident-ai.com/v1/prompts/{alias}/commits", {
  method: "GET",
  headers: {
    "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
  },
});

const data = await response.json();
console.log(data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.confident-ai.com/v1/prompts/{alias}/commits", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.confident-ai.com/v1/prompts/{alias}/commits"))
            .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
            .GET()
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let response = reqwest::Client::new()
        .get("https://api.confident-ai.com/v1/prompts/{alias}/commits")
        .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
        .send()
        .await?;

    println!("{}", response.text().await?);

    Ok(())
}

브랜치로 프롬프트 가져오기 (Pull Prompts By Branch)

alias와 브랜치 이름을 사용해 프롬프트의 특정 스냅샷을 가져올 수도 있어요.

Python

from deepeval.prompt import Prompt

prompt = Prompt(alias="YOUR-PROMPT-ALIAS")
prompt.pull(branch="MY-BRANCH-NAME")

기본적으로 Confident AI는 브랜치의 가장 최근 커밋을 반환해요.

TypeScript

import { Prompt } from "deepeval";

const prompt = new Prompt({ alias: "YOUR-PROMPT-ALIAS" });
await prompt.pull({ branch: "MY-BRANCH-NAME"});

기본적으로 Confident AI는 프롬프트의 가장 최근 커밋을 반환해요.

curl

Request (GET /v1/prompts/{alias}/commits/{hash}) — API reference

curl -X GET "https://api.confident-ai.com/v1/prompts/{alias}/commits/{hash}" \
  -H "CONFIDENT_API_KEY: <PROJECT-API-KEY>"

import requests

response = requests.get(
    "https://api.confident-ai.com/v1/prompts/{alias}/commits/{hash}",
    headers={
        "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
    },
)

print(response.json())

const response = await fetch("https://api.confident-ai.com/v1/prompts/{alias}/commits/{hash}", {
  method: "GET",
  headers: {
    "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
  },
});

const data = await response.json();
console.log(data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.confident-ai.com/v1/prompts/{alias}/commits/{hash}", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.confident-ai.com/v1/prompts/{alias}/commits/{hash}"))
            .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
            .GET()
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let response = reqwest::Client::new()
        .get("https://api.confident-ai.com/v1/prompts/{alias}/commits/{hash}")
        .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
        .send()
        .await?;

    println!("{}", response.text().await?);

    Ok(())
}

branch 쿼리 파라미터를 전달해 최신 커밋을 가져올 브랜치를 지정할 수 있어요.

브랜치 작업 (Branch Operations)

새 브랜치 만들기, 브랜치 이름 바꾸기, 브랜치 삭제, 모든 브랜치 나열 같은 브랜치 작업도 수행할 수 있어요.

브랜치 나열

from deepeval.prompt import Prompt

prompt = Prompt(alias="YOUR-PROMPT-ALIAS")
prompt.get_branches()

import { Prompt } from "deepeval";

const prompt = new Prompt({ alias: "YOUR-PROMPT-ALIAS" });
await prompt.getBranches();

  curl https://api.confident-ai.com/v1/prompts/PROMPT-ALIAS/branches \
    -H "CONFIDENT_API_KEY: <PROJECT-API-KEY>"

브랜치 생성

from deepeval.prompt import Prompt

prompt = Prompt(alias="YOUR-PROMPT-ALIAS")
prompt.create_branch(branch="NEW-BRANCH")

import { Prompt } from "deepeval";

const prompt = new Prompt({ alias: "YOUR-PROMPT-ALIAS"});
await prompt.createBranch({ branch: "NEW-BRANCH"});

  curl -X POST https://api.confident-ai.com/v1/prompts/PROMPT-ALIAS/branches \
    -H "CONFIDENT_API_KEY: <PROJECT-API-KEY>" \
    -H "Content-Type: application/json"

브랜치 업데이트

from deepeval.prompt import Prompt

prompt = Prompt(alias="YOUR-PROMPT-ALIAS", branch="OLD-BRANCH-NAME")
prompt.update_branch(name="NEW-BRANCH-NAME")

import { Prompt } from "deepeval";

const prompt = new Prompt({ alias: "YOUR-PROMPT-ALIAS", branch: "OLD-BRANCH-NAME" });
await prompt.updateBranch({ name: "NEW-BRANCH-NAME"});

  curl -X PUT https://api.confident-ai.com/v1/prompts/PROMPT-ALIAS/branches/BRANCH-ID \
    -H "CONFIDENT_API_KEY: <PROJECT-API-KEY>" \
    -H "Content-Type: application/json" \
    -d '{
      "name": "RenamedBranch"
    }'

브랜치 삭제

from deepeval.prompt import Prompt

prompt = Prompt(alias="YOUR-PROMPT-ALIAS", branch="OLD-BRANCH-NAME")
prompt.delete_branch(branch="NEW-BRANCH-NAME")

import { Prompt } from "deepeval";

const prompt = new Prompt({ alias: "YOUR-PROMPT-ALIAS", branch: "OLD-BRANCH-NAME" });
await prompt.deleteBranch({ branch: "NEW-BRANCH-NAME"});

  curl -X DELETE https://api.confident-ai.com/v1/prompts/PROMPT-ALIAS/branches/BRANCH-ID \
    -H "CONFIDENT_API_KEY: <PROJECT-API-KEY>"

프롬프트가 어떻게 가져와질까요? (How Are Prompts Pulled?)

Confident AI는 API 호출 지연 시간을 최소화하고 프롬프트 가용성을 보장하기 위해 클라이언트 측에서 프롬프트를 자동으로 캐시해요. 이는 프로덕션 환경에서 특히 유용해요.

캐시 (Cache)

sequenceDiagram
    participant App as Your Application
    participant DeepEval as DeepEval
    participant Cache as DeepEval Cache
    participant API as Confident AI API

    App->>DeepEval: Pull Prompt
    DeepEval->>Cache: Check cache
    Cache-->>DeepEval: Cached Prompt Data
    DeepEval-->>App: Prompt Data
    Note over Cache,API: Refetching (every 60s)
    Cache->>API: GET /v1/prompts
    API-->>Cache: Update Prompt Cache

캐시 없음 (No Cache)

sequenceDiagram
    participant App as Your Application
    participant DeepEval as DeepEval
    participant Cache as DeepEval Cache
    participant API as Confident AI API

    Note over App,API: Caching Disabled (refresh=0)
    App->>DeepEval: Pull Prompt
    DeepEval->>Cache: Bypass cache
    Cache->>API: GET /v1/prompts
    API-->>Cache: Prompt Data
    Cache-->>DeepEval: Prompt Data
    DeepEval-->>App: Prompt Data
    Note over Cache,API: Direct API call every time

새로 고침 주기 커스터마이즈

기본적으로 캐시는 60초마다 다시 가져오는데, DeepEval이 캐시된 프롬프트를 Confident AI의 최신 버전으로 자동 업데이트해요. refresh 파라미터를 다른 값으로 설정해 재정의할 수 있어요. 가져오기는 비동기로 이뤄져 애플리케이션을 막지 않아요.

Python

from deepeval.prompt import Prompt

prompt = Prompt(alias="YOUR-PROMPT-ALIAS")
prompt.pull(refresh=60)
interpolated_prompt = prompt.interpolate(name="Joe")

TypeScript

import { Prompt } from "deepeval";

const prompt = new Prompt({ alias: "YOUR-PROMPT-ALIAS" });
await prompt.pull({ refresh: 60 });
const interpolatedPrompt = prompt.interpolate({ name: "Joe" });

캐시 구성

캐싱을 비활성화하려면 refresh=0으로 설정해요. 그러면 프롬프트를 가져올 때마다 API 호출을 강제하게 되며, 개발과 테스트에 특히 유용해요.

Python

from deepeval.prompt import Prompt

prompt = Prompt(alias="YOUR-PROMPT-ALIAS")
prompt.pull(refresh=0)
interpolated_prompt = prompt.interpolate(name="Joe")

TypeScript

import { Prompt } from "deepeval";

const prompt = new Prompt({ alias: "YOUR-PROMPT-ALIAS" });
await prompt.pull({ refresh: 0 });
const interpolatedPrompt = prompt.interpolate({ name: "Joe" });

고급 사용법 (Advanced Usage)

이전 섹션에서 배웠듯이, 프롬프트는 텍스트/메시지뿐 아니라 모델 설정(provider, name, parameters), 아웃풋 타입, 툴까지 버전화하는 추가 옵션이 있어요.

모델 설정 사용 (Using model settings)

프롬프트를 가져온 뒤 model_settings 속성을 통해 프롬프트 버전에 구성된 모델 설정에 접근할 수 있어요. 모델 설정에는 provider, 모델 이름, 모델 파라미터(temperature, max_tokens 등)가 포함돼요.

Python

from deepeval.prompt import Prompt
from openai import OpenAI

prompt = Prompt(alias="YOUR-PROMPT-ALIAS")
prompt.pull()
interpolated_prompt = prompt.interpolate()
settings = prompt.model_settings

# Use model settings (provider, name, parameters) in your OpenAI call
response = OpenAI().chat.completions.create(
    model=settings.name,
    messages=interpolated_prompt,
    temperature=settings.temperature,
    max_tokens=settings.max_tokens,
    top_p=settings.top_p,
    frequency_penalty=settings.frequency_penalty,
    presence_penalty=settings.presence_penalty,
    stop=settings.stop_sequence,
)

print(response.choices[0].message.content)

TypeScript

import { Prompt } from "deepeval";
import { OpenAI } from "openai";

const prompt = new Prompt({ alias: "YOUR-PROMPT-ALIAS" });
await prompt.pull();
const interpolatedPrompt = prompt.interpolate();
const settings = prompt.modelSettings;

// Use model settings (provider, name, parameters) in your OpenAI call
const openai = new OpenAI();
const response = await openai.chat.completions.create({
  model: settings.name,
  messages: interpolatedPrompt as any[],
  temperature: settings.temperature,
  max_tokens: settings.maxTokens,
  top_p: settings.topP,
  frequency_penalty: settings.frequencyPenalty,
  presence_penalty: settings.presencePenalty,
  stop: settings.stopSequence,
});

console.log(response.choices[0].message.content);

curl

Request (GET /v1/prompts/{alias}/versions/{version}) — API reference

curl -X GET "https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}" \
  -H "CONFIDENT_API_KEY: <PROJECT-API-KEY>"

import requests

response = requests.get(
    "https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}",
    headers={
        "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
    },
)

print(response.json())

const response = await fetch("https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}", {
  method: "GET",
  headers: {
    "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
  },
});

const data = await response.json();
console.log(data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}"))
            .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
            .GET()
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let response = reqwest::Client::new()
        .get("https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}")
        .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
        .send()
        .await?;

    println!("{}", response.text().await?);

    Ok(())
}

응답에는 구성된 모델 설정을 담은 modelSettings 객체가 포함돼요.

모델 설정은 선택 사항이에요. 프롬프트 버전에 모델 설정이 없으면 model_settings는 None이 돼요.

아웃풋 타입 사용 (Using output type)

프롬프트를 가져온 뒤 output_type과 output_schema 속성을 통해 아웃풋 구성을 접근할 수 있어요. LLM에서 구조화된 아웃풋을 강제하고 싶을 때 유용해요.

Python

from deepeval.prompt import Prompt
from deepeval.prompt.api import OutputType
from openai import OpenAI

prompt = Prompt(alias="YOUR-PROMPT-ALIAS")
prompt.pull()
interpolated_prompt = prompt.interpolate()

# Build response_format based on output type
response_format = None
if prompt.output_type == OutputType.JSON:
    response_format = {"type": "json_object"}
elif prompt.output_type == OutputType.SCHEMA:
    response_format = {
        "type": "json_schema",
        "json_schema": prompt.output_schema
    }

# Use output type in your OpenAI call
response = OpenAI().chat.completions.create(
    model="gpt-4o",
    messages=interpolated_prompt,
    response_format=response_format,
)

print(response.choices[0].message.content)

TypeScript

import { Prompt, OutputType } from "deepeval";
import { OpenAI } from "openai";

const prompt = new Prompt({ alias: "YOUR-PROMPT-ALIAS" });
await prompt.pull();
const interpolatedPrompt = prompt.interpolate();

// Build response_format based on output type
let responseFormat: any = undefined;
if (prompt.outputType === OutputType.JSON) {
  responseFormat = { type: "json_object" };
} else if (prompt.outputType === OutputType.SCHEMA) {
  responseFormat = {
    type: "json_schema",
    json_schema: prompt.outputSchema,
  };
}

// Use output type in your OpenAI call
const openai = new OpenAI();
const response = await openai.chat.completions.create({
  model: "gpt-4o",
  messages: interpolatedPrompt as any[],
  response_format: responseFormat,
});

console.log(response.choices[0].message.content);

curl

Request (GET /v1/prompts/{alias}/versions/{version}) — API reference

curl -X GET "https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}" \
  -H "CONFIDENT_API_KEY: <PROJECT-API-KEY>"

import requests

response = requests.get(
    "https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}",
    headers={
        "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
    },
)

print(response.json())

const response = await fetch("https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}", {
  method: "GET",
  headers: {
    "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
  },
});

const data = await response.json();
console.log(data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}"))
            .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
            .GET()
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let response = reqwest::Client::new()
        .get("https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}")
        .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
        .send()
        .await?;

    println!("{}", response.text().await?);

    Ok(())
}

응답에는 아웃풋 구성을 위한 outputType과 outputSchema 필드가 포함돼요. outputType이 SCHEMA면 outputSchema 필드에 아웃풋 스키마 정의가 담겨 있어요.

사용 가능한 아웃풋 타입은:

• TEXT — 일반 텍스트 아웃풋 (기본값)
• JSON — JSON 포맷 아웃풋 ({"type": "json_object"}로 매핑)
• SCHEMA — 스키마에 대해 검증된 구조적 아웃풋 ({"type": "json_schema", ...}로 매핑)

툴 사용 (Using tools)

프롬프트를 가져온 뒤 tools 속성을 통해 프롬프트 버전에 정의된 툴에 접근할 수 있어요. 각 툴에는:

• name: 툴의 이름
• description: 툴이 무엇을 하는지에 대한 설명
• input_schema: 툴의 인풋 파라미터를 정의하는 JSON 스키마
• mode: 툴 모드 (ALLOW_ADDITIONAL, NO_ADDITIONAL, 또는 STRICT)

Python

from deepeval.prompt import Prompt
from openai import OpenAI

prompt = Prompt(alias="YOUR-PROMPT-ALIAS")
prompt.pull()
interpolated_prompt = prompt.interpolate()

# Convert prompt tools to OpenAI format
openai_tools = [
    {
        "type": "function",
        "function": {
            "name": tool.name,
            "description": tool.description,
            "parameters": tool.input_schema,
            "strict": tool.mode == "STRICT",
        },
    }
    for tool in prompt.tools
]

# Use tools in your OpenAI call
response = OpenAI().chat.completions.create(
    model="gpt-4o",
    messages=interpolated_prompt,
    tools=openai_tools,
)

print(response.choices[0].message)

TypeScript

import { Prompt } from "deepeval";
import { OpenAI } from "openai";

const prompt = new Prompt({ alias: "YOUR-PROMPT-ALIAS" });
await prompt.pull();
const interpolatedPrompt = prompt.interpolate();

// Convert prompt tools to OpenAI format
const openaiTools = prompt.tools.map((tool) => ({
  type: "function" as const,
  function: {
    name: tool.name,
    description: tool.description,
    parameters: tool.inputSchema,
    strict: tool.mode === "STRICT",
  },
}));

// Use tools in your OpenAI call
const openai = new OpenAI();
const response = await openai.chat.completions.create({
  model: "gpt-4o",
  messages: interpolatedPrompt as any[],
  tools: openaiTools,
});

console.log(response.choices[0].message);

curl

Request (GET /v1/prompts/{alias}/versions/{version}) — API reference

curl -X GET "https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}" \
  -H "CONFIDENT_API_KEY: <PROJECT-API-KEY>"

import requests

response = requests.get(
    "https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}",
    headers={
        "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
    },
)

print(response.json())

const response = await fetch("https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}", {
  method: "GET",
  headers: {
    "CONFIDENT_API_KEY": "<PROJECT-API-KEY>",
  },
});

const data = await response.json();
console.log(data);

package main

import (
	"fmt"
	"io"
	"net/http"
)

func main() {
	req, err := http.NewRequest("GET", "https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}", nil)
	if err != nil {
		panic(err)
	}
	req.Header.Set("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		panic(err)
	}
	defer res.Body.Close()

	out, err := io.ReadAll(res.Body)
	if err != nil {
		panic(err)
	}

	fmt.Println(string(out))
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
    public static void main(String[] args) throws Exception {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}"))
            .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
            .GET()
            .build();

        HttpResponse<String> response = HttpClient.newHttpClient()
            .send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let response = reqwest::Client::new()
        .get("https://api.confident-ai.com/v1/prompts/{alias}/versions/{version}")
        .header("CONFIDENT_API_KEY", "<PROJECT-API-KEY>")
        .send()
        .await?;

    println!("{}", response.text().await?);

    Ok(())
}

응답에는 각 툴의 name, description, inputSchema, mode를 가진 tools 배열이 포함돼요.

이미지 사용 (Using images)

이미지를 포함하는 프롬프트의 경우, 파싱해 선택한 MLLM에 전달하는 방법은 다음과 같아요:

Python

deepeval 파이썬 SDK는 convert_to_multi_modal_array라는 유틸리티 메서드를 제공해요. 이 메서드는 [DEEPEVAL:IMAGE:url] 형식의 이미지가 포함된 문자열을 문자열과 MLLMImage 항목의 목록으로 변환하는 데 유용해요.

from deepeval.prompt import Prompt
from deepeval.utils import convert_to_multi_modal_array

prompt = Prompt(alias="YOUR-PROMPT-ALIAS")
prompt.pull()

multimodal_array = convert_to_multi_modal_array(prompt.text)

여기서 multimodal_array는 문자열과 MLLMImage를 담은 목록이에요. 이 목록을 순회해 이미지가 포함된 messages 배열을 만들어 MLLM에 전달할 수 있어요. openai용 messages 배열을 만드는 예시는 다음과 같아요:

messages = []
for element in multimodal_array:
    if isinstance(element, str):
        messages.append({"type": "text", "text": element})
    elif isinstance(element, MLLMImage):
      if element.url:
          messages.append(
              {
                  "type": "image_url",
                  "image_url": {"url": element.url},
              }
          )

TypeScript

[DEEPEVAL:IMAGE:url] 형식의 이미지가 포함된 문자열을 문자열과 URL 배열로 변환하는 커스텀 메서드를 사용할 수 있어요.

const parseMultimodalString = (s: string) => {
  const PATTERN = /\[DEEPEVAL:IMAGE:(.*?)\]/g;

  const result = [];
  let lastEnd = 0;
  let match;

  while ((match = PATTERN.exec(s)) !== null) {
    const start = match.index;
    const end = PATTERN.lastIndex;

    if (start > lastEnd) {
      result.push(s.slice(lastEnd, start));
    }

    const imageUrl = match[1];
    result.push({ url: imageUrl });

    lastEnd = end;
  }

  if (lastEnd < s.length) {
    result.push(s.slice(lastEnd));
  }

  return result;
}

이 메서드로 프롬프트 텍스트에서 multimodalArray를 얻고 messages 배열을 구성해 MLLM에 전달할 수 있어요. openai 형식 메시지를 만드는 데 사용하는 예시는 다음과 같아요:

import { Prompt } from "deepeval";

const prompt = new Prompt({ alias: "YOUR-PROMPT-ALIAS" });
await prompt.pull();

const multimodalArray = parseMultimodalString(prompt.text);

const messages = [];

더 알아보기

• 프롬프트 버전 관리
• 프롬프트 관리 자동화
• 실험