Skip to main content
이 가이드는 OpenAI 채팅 모델 시작하기에 대한 간략한 개요를 제공합니다. OpenAI의 최신 모델, 비용, 컨텍스트 윈도우, 지원되는 입력 유형에 대한 정보는 OpenAI Platform 문서에서 확인할 수 있습니다.
API Reference모든 기능과 구성 옵션에 대한 자세한 문서는 ChatOpenAI API reference를 참조하세요.
Azure에서 호스팅되는 OpenAI 모델특정 OpenAI 모델은 Microsoft Azure platform을 통해서도 액세스할 수 있습니다. Azure OpenAI 서비스를 사용하려면 AzureChatOpenAI 통합을 사용하세요.

Overview

Integration details

ClassPackageSerializableJS/TS SupportDownloadsLatest Version
ChatOpenAIlangchain-openaibeta(npm)Downloads per monthPyPI - Latest version

Model features

Tool callingStructured outputImage inputAudio inputVideo inputToken-level streamingNative asyncToken usageLogprobs

Setup

OpenAI 모델에 액세스하려면 langchain-openai 통합 패키지를 설치하고 OpenAI Platform API 키를 획득해야 합니다.

Installation

pip install -U langchain-openai

Credentials

platform.openai.com에 가입하고 API 키를 생성하세요. 완료했다면 환경에서 OPENAI_API_KEY 환경 변수를 설정하세요:
import getpass
import os

if not os.environ.get("OPENAI_API_KEY"):
    os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter your OpenAI API key: ")
모델 호출에 대한 자동 추적을 원하시면 LangSmith API 키도 설정할 수 있습니다:
os.environ["LANGSMITH_API_KEY"] = getpass.getpass("Enter your LangSmith API key: ")
os.environ["LANGSMITH_TRACING"] = "true"

Instantiation

이제 모델 객체를 인스턴스화하고 응답을 생성할 수 있습니다:
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-5-nano",
    # stream_usage=True,
    # temperature=None,
    # max_tokens=None,
    # timeout=None,
    # reasoning_effort="low",
    # max_retries=2,
    # api_key="...",  # if you prefer to pass api key in directly instaed of using env vars
    # base_url="...",
    # organization="...",
    # other params...
)
사용 가능한 모델 매개변수의 전체 목록은 ChatOpenAI API Reference를 참조하세요.

Invocation

messages = [
    (
        "system",
        "You are a helpful assistant that translates English to French. Translate the user sentence.",
    ),
    ("human", "I love programming."),
]
ai_msg = llm.invoke(messages)
ai_msg
AIMessage(content="J'adore la programmation.", additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 5, 'prompt_tokens': 31, 'total_tokens': 36}, 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_3aa7262c27', 'finish_reason': 'stop', 'logprobs': None}, id='run-63219b22-03e3-4561-8cc4-78b7c7c3a3ca-0', usage_metadata={'input_tokens': 31, 'output_tokens': 5, 'total_tokens': 36})
print(ai_msg.text)
J'adore la programmation.

Streaming usage metadata

OpenAI의 Chat Completions API는 기본적으로 토큰 사용 통계를 스트리밍하지 않습니다 (API 참조 여기 참조). ChatOpenAI 또는 AzureChatOpenAI로 스트리밍할 때 토큰 수를 복구하려면 초기화 매개변수로 stream_usage=True를 설정하거나 호출 시 설정하세요:
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4.1-mini", stream_usage=True)  

Tool calling

OpenAI는 도구와 그 인수를 설명하고 모델이 호출할 도구와 해당 도구에 대한 입력이 포함된 JSON 객체를 반환하도록 하는 tool calling API를 제공합니다(여기서는 “tool calling”과 “function calling”을 같은 의미로 사용합니다). 도구 호출은 도구 사용 체인과 에이전트를 구축하고 모델에서 구조화된 출력을 얻는 데 매우 유용합니다.

ChatOpenAI.bind_tools()

ChatOpenAI.bind_tools를 사용하면 Pydantic 클래스, dict 스키마, LangChain 도구 또는 함수를 모델에 도구로 쉽게 전달할 수 있습니다. 내부적으로 이들은 다음과 같은 OpenAI 도구 스키마로 변환됩니다:
{
    "name": "...",
    "description": "...",
    "parameters": {...}  # JSONSchema
}
그리고 모든 모델 호출에 전달됩니다.
from pydantic import BaseModel, Field


class GetWeather(BaseModel):
    """Get the current weather in a given location"""

    location: str = Field(..., description="The city and state, e.g. San Francisco, CA")


llm_with_tools = llm.bind_tools([GetWeather])
ai_msg = llm_with_tools.invoke(
    "what is the weather like in San Francisco",
)
ai_msg
AIMessage(content='', additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 17, 'prompt_tokens': 68, 'total_tokens': 85}, 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_3aa7262c27', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-1617c9b2-dda5-4120-996b-0333ed5992e2-0', tool_calls=[{'name': 'GetWeather', 'args': {'location': 'San Francisco, CA'}, 'id': 'call_o9udf3EVOWiV4Iupktpbpofk', 'type': 'tool_call'}], usage_metadata={'input_tokens': 68, 'output_tokens': 17, 'total_tokens': 85})

strict=True

langchain-openai>=0.1.21 필요
2024년 8월 6일부터 OpenAI는 도구를 호출할 때 도구 인수 스키마가 모델에 의해 준수되도록 강제하는 strict 인수를 지원합니다. 자세한 내용은 여기를 참조하세요: platform.openai.com/docs/guides/function-calling 참고: strict=True인 경우 도구 정의도 검증되며 JSON 스키마의 하위 집합만 허용됩니다. 중요한 점은 스키마에 선택적 인수(기본값이 있는 인수)가 있으면 안 된다는 것입니다. 지원되는 스키마 유형에 대한 전체 문서는 여기를 참조하세요: platform.openai.com/docs/guides/structured-outputs/supported-schemas.
llm_with_tools = llm.bind_tools([GetWeather], strict=True)
ai_msg = llm_with_tools.invoke(
    "what is the weather like in San Francisco",
)
ai_msg
AIMessage(content='', additional_kwargs={'tool_calls': [{'id': 'call_jUqhd8wzAIzInTJl72Rla8ht', 'function': {'arguments': '{"location":"San Francisco, CA"}', 'name': 'GetWeather'}, 'type': 'function'}], 'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 17, 'prompt_tokens': 68, 'total_tokens': 85}, 'model_name': 'gpt-4o-2024-05-13', 'system_fingerprint': 'fp_3aa7262c27', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-5e3356a9-132d-4623-8e73-dd5a898cf4a6-0', tool_calls=[{'name': 'GetWeather', 'args': {'location': 'San Francisco, CA'}, 'id': 'call_jUqhd8wzAIzInTJl72Rla8ht', 'type': 'tool_call'}], usage_metadata={'input_tokens': 68, 'output_tokens': 17, 'total_tokens': 85})

AIMessage.tool_calls

AIMessage에 tool_calls 속성이 있는 것을 확인하세요. 이것은 모델 공급자에 관계없이 표준화된 ToolCall 형식으로 포함되어 있습니다.
ai_msg.tool_calls
[{'name': 'GetWeather',
  'args': {'location': 'San Francisco, CA'},
  'id': 'call_jUqhd8wzAIzInTJl72Rla8ht',
  'type': 'tool_call'}]
도구 바인딩 및 도구 호출 출력에 대한 자세한 내용은 tool calling 문서를 참조하세요.

Structured output and tool calls

OpenAI의 structured output 기능은 도구 호출과 동시에 사용할 수 있습니다. 모델은 도구 호출 또는 원하는 스키마를 준수하는 응답을 생성합니다. 아래 예제를 참조하세요:
from langchain_openai import ChatOpenAI
from pydantic import BaseModel


def get_weather(location: str) -> None:
    """Get weather at a location."""
    return "It's sunny."


class OutputSchema(BaseModel):
    """Schema for response."""

    answer: str
    justification: str


llm = ChatOpenAI(model="gpt-4.1")

structured_llm = llm.bind_tools(
    [get_weather],
    response_format=OutputSchema,
    strict=True,
)

# Response contains tool calls:
tool_call_response = structured_llm.invoke("What is the weather in SF?")

# structured_response.additional_kwargs["parsed"] contains parsed output
structured_response = structured_llm.invoke(
    "What weighs more, a pound of feathers or a pound of gold?"
)

Custom tools

langchain-openai>=0.3.29 필요
Custom tools는 임의의 문자열 입력을 가진 도구를 지원합니다. 문자열 인수가 길거나 복잡할 것으로 예상되는 경우 특히 유용할 수 있습니다.
from langchain_openai import ChatOpenAI, custom_tool
from langchain.agents import create_agent


@custom_tool
def execute_code(code: str) -> str:
    """Execute python code."""
    return "27"


llm = ChatOpenAI(model="gpt-5", use_responses_api=True)

agent = create_agent(llm, [execute_code])

input_message = {"role": "user", "content": "Use the tool to calculate 3^3."}
for step in agent.stream(
    {"messages": [input_message]},
    stream_mode="values",
):
    step["messages"][-1].pretty_print()
================================ Human Message =================================

Use the tool to calculate 3^3.
================================== Ai Message ==================================

[{'id': 'rs_68b7336cb72081a080da70bf5e980e4e0d6082d28f91357a', 'summary': [], 'type': 'reasoning'}, {'call_id': 'call_qyKsJ4XlGRudbIJDrXVA2nQa', 'input': 'print(3**3)', 'name': 'execute_code', 'type': 'custom_tool_call', 'id': 'ctc_68b7336f718481a0b39584cd35fbaa5d0d6082d28f91357a', 'status': 'completed'}]
Tool Calls:
  execute_code (call_qyKsJ4XlGRudbIJDrXVA2nQa)
 Call ID: call_qyKsJ4XlGRudbIJDrXVA2nQa
  Args:
    __arg1: print(3**3)
================================= Tool Message =================================
Name: execute_code

[{'type': 'custom_tool_call_output', 'output': '27'}]
================================== Ai Message ==================================

The result of calculating \(3^3\) is **27**.

Structured output

ChatOpenAI여러 가지 방법으로 구조화된 출력을 반환할 수 있습니다. 간략한 개요는 아래를 참조하세요:

ChatOpenAI.with_structured_output()

strict=Truelangchain-openai>=0.1.21을 필요로 함
.with_structured_output 메서드를 사용하면 모델이 스키마에 맞는 출력을 반환하도록 할 수 있습니다. 스키마는 Pydantic 클래스 또는 JSON 스키마로 지정할 수 있습니다:
from langchain_openai import ChatOpenAI
from pydantic import BaseModel, Field


class Joke(BaseModel):
    """Joke to tell user."""

    setup: str = Field(description="The setup of the joke")
    punchline: str = Field(description="The punchline to the joke")


# Pass `strict=True` to enable Structured Outputs for supported models.
llm = ChatOpenAI(model="gpt-4.1-mini", temperature=0)
structured_llm = llm.with_structured_output(Joke, strict=True)

structured_llm.invoke("Tell me a joke about cats")
Joke(setup='Why was the cat sitting on the computer?', punchline='To keep an eye on the mouse!')
자세한 내용은 여기를 참조하세요.

Responses API

langchain-openai>=0.3.10 필요
OpenAI의 Responses API는 GPT-4o, GPT-4.1, GPT-5 시리즈 모델과 함께 사용할 수 있는 베타 API입니다. Responses API는 대화 상태를 관리하고, computer-usecode interpreter와 같은 고급 도구를 지원하며, reasoning을 활성화합니다. ChatOpenAI는 use_responses_api가 설정되거나 reasoning 또는 include 같은 Responses-only 매개변수가 지정된 경우 자동으로 Responses API를 사용합니다.
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-4.1-mini",
    use_responses_api=True,  
)

Computer use

OpenAI는 모델이 컴퓨터 인터페이스와 상호작용할 수 있도록 하는 computer-use 도구를 구현합니다. 예제 사용:
import base64

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-5-nano")

llm_with_tools = llm.bind_tools([{"type": "computer"}])

# Prep screenshots
def encode_screenshot(image_path: str) -> str:
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")


screenshot_1_base64 = encode_screenshot("screenshot_1.png")
screenshot_2_base64 = encode_screenshot("screenshot_2.png")

input_message = {
    "role": "user",
    "content": [
        {
            "type": "text",
            "text": (
                "Click the red X to close and reveal my Desktop. "
                "Proceed, no confirmation needed."
            ),
        },
        {
            "type": "input_image",
            "image_url": f"data:image/png;base64,{screenshot_1_base64}",
        },
    ],
}

# Invoke model
response = llm_with_tools.invoke(
    [input_message],
    reasoning={
        "generate_summary": "concise",
    },
)
응답에는 content에 computer-use 도구에 대한 호출이 포함됩니다:
response.content
[{'id': 'rs_685da051742c81a1bb35ce46a9f3f53406b50b8696b0f590',
  'summary': [{'text': "Clicking red 'X' to show desktop",
    'type': 'summary_text'}],
  'type': 'reasoning'},
 {'id': 'cu_685da054302481a1b2cc43b56e0b381706b50b8696b0f590',
  'action': {'button': 'left', 'type': 'click', 'x': 14, 'y': 38},
  'call_id': 'call_zmQerFBh4PbBE8mQoQHkfkwy',
  'pending_safety_checks': [],
  'status': 'completed',
  'type': 'computer_call'}]
다음으로 이러한 속성을 가진 ToolMessage를 구성합니다:
  1. computer-call의 call_id와 일치하는 tool_call_id를 가집니다.
  2. additional_kwargs{"type": "computer_call_output"}를 가집니다.
  3. 내용은 image_url 또는 input_image 출력 블록입니다(형식은 OpenAI docs 참조).
from langchain.messages import ToolMessage

tool_call_id = next(
    item["call_id"] for item in response.content if item["type"] == "computer_call"
)

tool_message = ToolMessage(
    content=[
        {
            "type": "input_image",
            "image_url": f"data:image/png;base64,{screenshot_2_base64}",
        }
    ],
    # content=f"data:image/png;base64,{screenshot_2_base64}",  # <-- also acceptable
    tool_call_id=tool_call_id,
    additional_kwargs={"type": "computer_call_output"},
)
이제 메시지 히스토리를 사용하여 모델을 다시 호출할 수 있습니다:
messages = [
    input_message,
    response,
    tool_message,
]

response_2 = llm_with_tools.invoke(
    messages,
    reasoning={
        "generate_summary": "concise",
    },
)
response_2.text
'VS Code has been closed, and the desktop is now visible.'
전체 시퀀스를 다시 전달하는 대신 previous_response_id를 사용할 수도 있습니다:
previous_response_id = response.response_metadata["id"]

response_2 = llm_with_tools.invoke(
    [tool_message],
    previous_response_id=previous_response_id,
    reasoning={
        "generate_summary": "concise",
    },
)
response_2.text
'The VS Code window is closed, and the desktop is now visible. Let me know if you need any further assistance.'

Code interpreter

OpenAI는 샌드박스화된 코드 생성 및 실행을 지원하는 code interpreter 도구를 구현합니다. 예제 사용:
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-4.1-mini",
    include=["code_interpreter_call.outputs"],  # optionally include outputs
)

llm_with_tools = llm.bind_tools(
    [
        {
            "type": "code_interpreter",
            # Create a new container
            "container": {"type": "auto"},
        }
    ]
)
response = llm_with_tools.invoke(
    "Write and run code to answer the question: what is 3^3?"
)
위 명령은 새 컨테이너를 생성했습니다. 기존 컨테이너 ID를 지정할 수도 있습니다:
code_interpreter_calls = [
    item for item in response.content if item["type"] == "code_interpreter_call"
]
assert len(code_interpreter_calls) == 1
container_id = code_interpreter_calls[0]["extras"]["container_id"]  

llm_with_tools = llm.bind_tools(
    [
        {
            "type": "code_interpreter",
            # Use an existing container
            "container": container_id,  
        }
    ]
)

Remote MCP

OpenAI는 MCP 서버에 대한 모델 생성 호출을 허용하는 remote MCP 도구를 구현합니다. 예제 사용:
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4.1-mini")

llm_with_tools = llm.bind_tools(
    [
        {
            "type": "mcp",
            "server_label": "deepwiki",
            "server_url": "https://mcp.deepwiki.com/mcp",
            "require_approval": "never",
        }
    ]
)
response = llm_with_tools.invoke(
    "What transport protocols does the 2025-03-26 version of the MCP "
    "spec (modelcontextprotocol/modelcontextprotocol) support?"
)
OpenAI는 때때로 원격 MCP 서버와 데이터를 공유하기 전에 승인을 요청합니다.위 명령에서는 모델이 승인을 요구하지 않도록 지시했습니다. 항상 승인을 요청하거나 특정 도구에 대해서만 항상 승인을 요청하도록 모델을 구성할 수도 있습니다:
llm_with_tools = llm.bind_tools(
    [
        {
            "type": "mcp",
            "server_label": "deepwiki",
            "server_url": "https://mcp.deepwiki.com/mcp",
            "require_approval": {
                "always": {
                    "tool_names": ["read_wiki_structure"]
                }
            }
        }
    ]
)
response = llm_with_tools.invoke(
    "What transport protocols does the 2025-03-26 version of the MCP "
    "spec (modelcontextprotocol/modelcontextprotocol) support?"
)
그러면 응답에 "mcp_approval_request" 유형의 블록이 포함될 수 있습니다.승인 요청에 대한 승인을 제출하려면 입력 메시지의 콘텐츠 블록으로 구성하세요:
approval_message = {
    "role": "user",
    "content": [
        {
            "type": "mcp_approval_response",
            "approve": True,
            "approval_request_id": block["id"],
        }
        for block in response.content
        if block["type"] == "mcp_approval_request"
    ]
}

next_response = llm_with_tools.invoke(
    [approval_message],
    # continue existing thread
    previous_response_id=response.response_metadata["id"]
)

Managing conversation state

Responses API는 conversation state 관리를 지원합니다.

Manually manage state

다른 채팅 모델과 마찬가지로 LangGraph를 사용하거나 수동으로 상태를 관리할 수 있습니다:
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4.1-mini", use_responses_api=True)

first_query = "Hi, I'm Bob."
messages = [{"role": "user", "content": first_query}]

response = llm.invoke(messages)
print(response.text)
Hi Bob! Nice to meet you. How can I assist you today?
second_query = "What is my name?"

messages.extend(
    [
        response,
        {"role": "user", "content": second_query},
    ]
)
second_response = llm.invoke(messages)
print(second_response.text)
You mentioned that your name is Bob. How can I assist you further, Bob?
LangGraph를 사용하여 인메모리 및 Postgres를 포함한 다양한 백엔드에서 대화 스레드를 관리할 수 있습니다. 시작하려면 이 튜토리얼을 참조하세요.

Passing previous_response_id

Responses API를 사용할 때 LangChain 메시지의 메타데이터에 "id" 필드가 포함됩니다. 이 ID를 후속 호출에 전달하면 대화가 계속됩니다. 이것은 청구 관점에서 수동으로 메시지를 전달하는 것과 동등합니다.
second_response = llm.invoke(
    "What is my name?",
    previous_response_id=response.id,  
)
print(second_response.text)
Your name is Bob. How can I help you today, Bob?
ChatOpenAI는 메시지 시퀀스의 마지막 응답을 사용하여 자동으로 previous_response_id를 지정할 수도 있습니다:
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-4.1-mini",
    use_previous_response_id=True,  
)
use_previous_response_id=True로 설정하면 가장 최근 응답까지의 입력 메시지가 요청 페이로드에서 삭제되고 previous_response_id가 가장 최근 응답의 ID를 사용하여 설정됩니다. 즉,
llm.invoke(
    [
        HumanMessage("Hello"),
        AIMessage("Hi there!", id="resp_123"),
        HumanMessage("How are you?"),
    ]
)
는 다음과 동등합니다:
llm.invoke([HumanMessage("How are you?")], previous_response_id="resp_123")

Reasoning output

일부 OpenAI 모델은 추론 프로세스를 설명하는 별도의 텍스트 콘텐츠를 생성합니다. 자세한 내용은 OpenAI의 reasoning documentation을 참조하세요. OpenAI는 모델의 추론 요약을 반환할 수 있습니다(원시 추론 토큰은 노출하지 않음). 이 요약을 반환하도록 ChatOpenAI를 구성하려면 reasoning 매개변수를 지정하세요. 이 매개변수가 설정되면 ChatOpenAI는 자동으로 Responses API로 라우팅됩니다.
from langchain_openai import ChatOpenAI

reasoning = {
    "effort": "medium",  # 'low', 'medium', or 'high'
    "summary": "auto",  # 'detailed', 'auto', or None
}

llm = ChatOpenAI(model="gpt-5-nano", reasoning=reasoning)
response = llm.invoke("What is 3^3?")

# Output
response.text
'3³ = 3 × 3 × 3 = 27.'
# Reasoning
for block in response.content_blocks:
    if block["type"] == "reasoning":
        print(block["reasoning"])
**Calculating the power of three**

The user is asking about 3 raised to the power of 3. That's a pretty simple calculation! I know that 3^3 equals 27, so I can say, "3 to the power of 3 equals 27." I might also include a quick explanation that it's 3 multiplied by itself three times: 3 × 3 × 3 = 27. So, the answer is definitely 27.

Fine-tuning

modelName 매개변수에 해당 값을 전달하여 파인튜닝된 OpenAI 모델을 호출할 수 있습니다. 일반적으로 ft:{OPENAI_MODEL_NAME}:{ORG_NAME}::{MODEL_ID} 형식을 사용합니다. 예를 들어:
fine_tuned_model = ChatOpenAI(
    temperature=0, model_name="ft:gpt-3.5-turbo-0613:langchain::7qTVM5AR"
)

fine_tuned_model.invoke(messages)
AIMessage(content="J'adore la programmation.", additional_kwargs={'refusal': None}, response_metadata={'token_usage': {'completion_tokens': 8, 'prompt_tokens': 31, 'total_tokens': 39}, 'model_name': 'ft:gpt-3.5-turbo-0613:langchain::7qTVM5AR', 'system_fingerprint': None, 'finish_reason': 'stop', 'logprobs': None}, id='run-0f39b30e-c56e-4f3b-af99-5c948c984146-0', usage_metadata={'input_tokens': 31, 'output_tokens': 8, 'total_tokens': 39})

Multimodal Inputs (images, PDFs, audio)

OpenAI에는 멀티모달 입력을 지원하는 모델이 있습니다. 이러한 모델에 이미지, PDF 또는 오디오를 전달할 수 있습니다. LangChain에서 이를 수행하는 방법에 대한 자세한 내용은 multimodal inputs 문서를 참조하세요. 다양한 모달리티를 지원하는 모델 목록은 OpenAI’s documentation에서 확인할 수 있습니다. 모든 모달리티에 대해 LangChain은 크로스 프로바이더 표준과 OpenAI의 네이티브 콘텐츠 블록 형식을 모두 지원합니다. 멀티모달 데이터를 ChatOpenAI에 전달하려면 데이터를 포함하는 콘텐츠 블록을 생성하고 아래와 같이 메시지에 통합하세요:
message = {
    "role": "user",
    "content": [
        {
            "type": "text",
            # Update prompt as desired
            "text": "Describe the (image / PDF / audio...)",
        },
        content_block,  
    ],
}
콘텐츠 블록의 예는 아래를 참조하세요.
사용 방법 가이드의 예제는 여기를 참조하세요.URLs:
# LangChain format
content_block = {
    "type": "image",
    "url": url_string,
}

# OpenAI Chat Completions format
content_block = {
    "type": "image_url",
    "image_url": {"url": url_string},
}
인라인 base64 데이터:
# LangChain format
content_block = {
    "type": "image",
    "base64": base64_string,
    "mime_type": "image/jpeg",
}

# OpenAI Chat Completions format
content_block = {
    "type": "image_url",
    "image_url": {
        "url": f"data:image/jpeg;base64,{base64_string}",
    },
}
참고: OpenAI는 PDF 입력에 대해 파일 이름을 지정해야 합니다. LangChain 형식을 사용할 때 filename 키를 포함하세요.자세한 내용은 여기를 참조하세요.사용 방법 가이드의 예제는 여기를 참조하세요.인라인 base64 데이터:
# LangChain format
content_block = {
    "type": "file",
    "base64": base64_string,
    "mime_type": "application/pdf",
    "filename": "my-file.pdf",  
}

# OpenAI Chat Completions format
content_block = {
    "type": "file",
    "file": {
        "filename": "my-file.pdf",
        "file_data": f"data:application/pdf;base64,{base64_string}",
    }
}
지원되는 모델 참조, 예: "gpt-4o-audio-preview".사용 방법 가이드의 예제는 여기를 참조하세요.인라인 base64 데이터:
# LangChain format
content_block = {
    "type": "audio",
    "mime_type": "audio/wav",  # or appropriate mime-type
    "base64": base64_string,
}

# OpenAI Chat Completions format
content_block = {
    "type": "input_audio",
    "input_audio": {"data": base64_string, "format": "wav"},
}

Predicted output

langchain-openai>=0.2.6 필요
일부 OpenAI 모델(gpt-4ogpt-4o-mini 시리즈 등)은 LLM의 예상 출력 중 알려진 부분을 미리 전달하여 지연 시간을 줄일 수 있는 Predicted Outputs를 지원합니다. 이는 모델 출력의 일부만 변경되는 텍스트 또는 코드 편집과 같은 경우에 유용합니다. 예제:
code = """
/// <summary>
/// Represents a user with a first name, last name, and username.
/// </summary>
public class User
{
    /// <summary>
    /// Gets or sets the user's first name.
    /// </summary>
    public string FirstName { get; set; }

    /// <summary>
    /// Gets or sets the user's last name.
    /// </summary>
    public string LastName { get; set; }

    /// <summary>
    /// Gets or sets the user's username.
    /// </summary>
    public string Username { get; set; }
}
"""

llm = ChatOpenAI(model="gpt-4o")
query = (
    "Replace the Username property with an Email property. "
    "Respond only with code, and with no markdown formatting."
)
response = llm.invoke(
    [{"role": "user", "content": query}, {"role": "user", "content": code}],
    prediction={"type": "content", "content": code},
)
print(response.content)
print(response.response_metadata)
/// <summary>
/// Represents a user with a first name, last name, and email.
/// </summary>
public class User
{
    /// <summary>
    /// Gets or sets the user's first name.
    /// </summary>
    public string FirstName { get; set; }

    /// <summary>
    /// Gets or sets the user's last name.
    /// </summary>
    public string LastName { get; set; }

    /// <summary>
    /// Gets or sets the user's email.
    /// </summary>
    public string Email { get; set; }
}
{'token_usage': {'completion_tokens': 226, 'prompt_tokens': 166, 'total_tokens': 392, 'completion_tokens_details': {'accepted_prediction_tokens': 49, 'audio_tokens': None, 'reasoning_tokens': 0, 'rejected_prediction_tokens': 107}, 'prompt_tokens_details': {'audio_tokens': None, 'cached_tokens': 0}}, 'model_name': 'gpt-4o-2024-08-06', 'system_fingerprint': 'fp_45cf54deae', 'finish_reason': 'stop', 'logprobs': None}
현재 예측은 추가 토큰으로 청구되며 지연 시간 감소 대신 사용량 및 비용이 증가할 수 있습니다.

Audio Generation (Preview)

langchain-openai>=0.2.3 필요
OpenAI는 gpt-4o-audio-preview 모델과 함께 오디오 입력 및 출력을 사용할 수 있는 새로운 audio generation feature를 제공합니다.
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="gpt-4o-audio-preview",
    temperature=0,
    model_kwargs={
        "modalities": ["text", "audio"],
        "audio": {"voice": "alloy", "format": "wav"},
    },
)

output_message = llm.invoke(
    [
        ("human", "Are you made by OpenAI? Just answer yes or no"),
    ]
)
output_message.additional_kwargs['audio']에는 다음과 같은 딕셔너리가 포함됩니다:
{
    'data': '<audio data b64-encoded',
    'expires_at': 1729268602,
    'id': 'audio_67127d6a44348190af62c1530ef0955a',
    'transcript': 'Yes.'
}
형식은 model_kwargs['audio']['format']에 전달된 것입니다. OpenAI expires_at에 도달하기 전에 오디오 데이터가 포함된 이 메시지를 메시지 히스토리의 일부로 모델에 다시 전달할 수도 있습니다.
출력 오디오는 AIMessage.additional_kwargsaudio 키 아래에 저장되지만, 입력 콘텐츠 블록은 HumanMessage.content 목록에서 input_audio 유형 및 키로 타입이 지정됩니다.자세한 내용은 OpenAI의 audio docs를 참조하세요.
history = [
    ("human", "Are you made by OpenAI? Just answer yes or no"),
    output_message,
    ("human", "And what is your name? Just give your name."),
]
second_output_message = llm.invoke(history)

Flex processing

OpenAI는 다양한 service tiers를 제공합니다. “flex” 티어는 요청에 대해 더 저렴한 가격을 제공하지만 응답이 더 오래 걸리고 리소스가 항상 사용 가능하지 않을 수 있습니다. 이 접근 방식은 모델 테스트, 데이터 향상 또는 비동기적으로 실행할 수 있는 작업을 포함한 중요하지 않은 작업에 가장 적합합니다. 사용하려면 service_tier="flex"로 모델을 초기화하세요:
llm = ChatOpenAI(model="o4-mini", service_tier="flex")
이것은 일부 모델에서만 사용할 수 있는 베타 기능입니다. 자세한 내용은 OpenAI docs를 참조하세요.

API reference

모든 기능 및 구성 옵션에 대한 자세한 문서는 ChatOpenAI API reference를 참조하세요.
Connect these docs programmatically to Claude, VSCode, and more via MCP for real-time answers.
I