## ChatOpenAI

This notebook covers how to get started with OpenAI chat models.

```
from langchain_core.messages import HumanMessage, SystemMessagefrom langchain_core.prompts import ChatPromptTemplatefrom langchain_openai import ChatOpenAI
```

```
llm = ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0)
```

The above cell assumes that your OpenAI API key is set in your environment variables. If you would rather manually specify your API key and/or organization ID, use the following code:

```
llm = ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0, api_key="YOUR_API_KEY", openai_organization="YOUR_ORGANIZATION_ID")
```

Remove the openai\_organization parameter should it not apply to you.

```
messages = [    ("system", "You are a helpful assistant that translates English to French."),    ("human", "Translate this sentence from English to French. I love programming."),]llm.invoke(messages)
```

```
AIMessage(content="J'adore programmer.", response_metadata={'token_usage': {'completion_tokens': 6, 'prompt_tokens': 34, 'total_tokens': 40}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-8591eae1-b42b-402b-a23a-dfdb0cd151bd-0')
```

## Chaining[​](#chaining "Direct link to Chaining")

We can chain our model with a prompt template like so:

```
prompt = ChatPromptTemplate.from_messages(    [        (            "system",            "You are a helpful assistant that translates {input_language} to {output_language}.",        ),        ("human", "{input}"),    ])chain = prompt | llmchain.invoke(    {        "input_language": "English",        "output_language": "German",        "input": "I love programming.",    })
```

```
AIMessage(content='Ich liebe Programmieren.', response_metadata={'token_usage': {'completion_tokens': 5, 'prompt_tokens': 26, 'total_tokens': 31}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'stop', 'logprobs': None}, id='run-94fa6741-c99b-4513-afce-c3f562631c79-0')
```

OpenAI has a [tool calling](https://platform.openai.com/docs/guides/function-calling) (we use “tool calling” and “function calling” interchangeably here) API that lets you describe tools and their arguments, and have the model return a JSON object with a tool to invoke and the inputs to that tool. tool-calling is extremely useful for building tool-using chains and agents, and for getting structured outputs from models more generally.

### ChatOpenAI.bind\_tools()[​](#chatopenai.bind_tools "Direct link to ChatOpenAI.bind_tools()")

With `ChatAnthropic.bind_tools`, we can easily pass in Pydantic classes, dict schemas, LangChain tools, or even functions as tools to the model. Under the hood these are converted to an Anthropic tool schemas, which looks like:

```
{    "name": "...",    "description": "...",    "parameters": {...}  # JSONSchema}
```

and passed in every model invocation.

```
from langchain_core.pydantic_v1 import BaseModel, Fieldclass 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={'tool_calls': [{'id': 'call_H7fABDuzEau48T10Qn0Lsh0D', 'function': {'arguments': '{"location":"San Francisco"}', 'name': 'GetWeather'}, 'type': 'function'}]}, response_metadata={'token_usage': {'completion_tokens': 15, 'prompt_tokens': 70, 'total_tokens': 85}, 'model_name': 'gpt-3.5-turbo-0125', 'system_fingerprint': 'fp_b28b39ffa8', 'finish_reason': 'tool_calls', 'logprobs': None}, id='run-b469135e-2718-446a-8164-eef37e672ba2-0', tool_calls=[{'name': 'GetWeather', 'args': {'location': 'San Francisco'}, 'id': 'call_H7fABDuzEau48T10Qn0Lsh0D'}])
```

### AIMessage.tool\_calls[​](#aimessage.tool_calls "Direct link to AIMessage.tool_calls")

Notice that the AIMessage has a `tool_calls` attribute. This contains in a standardized ToolCall format that is model-provider agnostic.

```
[{'name': 'GetWeather',  'args': {'location': 'San Francisco'},  'id': 'call_H7fABDuzEau48T10Qn0Lsh0D'}]
```

For more on binding tools and tool call outputs, head to the [tool calling](https://python.langchain.com/docs/modules/model_io/chat/function_calling/) docs.

## Fine-tuning[​](#fine-tuning "Direct link to Fine-tuning")

You can call fine-tuned OpenAI models by passing in your corresponding `modelName` parameter.

This generally takes the form of `ft:{OPENAI_MODEL_NAME}:{ORG_NAME}::{MODEL_ID}`. For example:

```
fine_tuned_model = ChatOpenAI(    temperature=0, model_name="ft:gpt-3.5-turbo-0613:langchain::7qTVM5AR")fine_tuned_model(messages)
```

```
AIMessage(content="J'adore la programmation.", additional_kwargs={}, example=False)
```