class ChatTogetherAIChatOpenAICompletions<ChatTogetherAICallOptions>Whether to include the raw OpenAI response in the output message's "additional_kwargs" field. Currently in experimental beta.
API key to use when making requests to OpenAI. Defaults to the value of
OPENAI_API_KEY environment variable.
Parameters for audio output. Required when audio output is requested with
modalities: ["audio"].
Learn more.
The async caller should be used by subclasses to make any async calls, which will thus benefit from the concurrency and retry logic.
Penalizes repeated tokens according to frequency
A path to the module that contains the class, eg. ["langchain", "llms"] Usually should be the same as the entrypoint the class is exported from.
Dictionary used to adjust the probability of specific tokens being generated
Whether to return log probabilities of the output tokens or not. If true, returns the log probabilities of each output token returned in the content of message.
Maximum number of tokens to generate in the completion. -1 returns as many tokens as possible given the prompt and the model's maximum context size.
Output types that you would like the model to generate for this request. Most models are capable of generating text, which is the default:
["text"]
The gpt-4o-audio-preview model can also be used to
generate audio. To request that
this model generate both text and audio responses, you can use:
["text", "audio"]
Model name to use
Holds any additional parameters that are valid to pass to openai.createCompletion that are not explicitly specified on this class.
Number of completions to generate for each prompt
Penalizes repeated tokens
Used by OpenAI to cache responses for similar requests to optimize your cache hit rates. Learn more.
Used by OpenAI to set cache retention time
Options for reasoning models.
Note that some options, like reasoning summaries, are only available when using the responses API. This option is ignored when not using a reasoning model.
Service tier to use for this request. Can be "auto", "default", or "flex" or "priority". Specifies the service tier for prioritization and latency optimization.
List of stop words to use when generating
Alias for stopSequences
List of stop words to use when generating
Whether to stream the results or not. Enabling disables tokenUsage reporting
Whether or not to include token usage data in streamed chunks.
Whether the model supports the strict argument when passing in tools.
If undefined the strict argument will not be passed to OpenAI.
Sampling temperature to use
Timeout to use when making requests to OpenAI.
An integer between 0 and 5 specifying the number of most likely tokens to return at each token position, each with an associated log probability. logprobs must be set to true if this parameter is used.
Total probability mass of tokens to consider at each step
Unique string identifier representing your end-user, which can help OpenAI to monitor and detect abuse.
Whether to print out response text.
The verbosity of the model's response.
Must be set to true in tenancies with Zero Data Retention. Setting to true will disable
output storage in the Responses API, but this DOES NOT enable Zero Data Retention in your
OpenAI organization or project. This must be configured directly with OpenAI.
See: https://platform.openai.com/docs/guides/your-data https://platform.openai.com/docs/api-reference/responses/create#responses-create-store
TogetherAI chat model integration.
The TogetherAI API is compatible to the OpenAI API with some limitations. View the full API ref at:
Generate a stream of events emitted by the internal steps of the runnable.
Use to create an iterator over StreamEvents that provide real-time information about the progress of the runnable, including StreamEvents from intermediate results.
A StreamEvent is a dictionary with the following schema:
event: string - Event names are of the format: on_[runnable_type]_(start|stream|end).name: string - The name of the runnable that generated the event.run_id: string - Randomly generated ID associated with the given execution of
the runnable that emitted the event. A child runnable that gets invoked as part of the execution of a
parent runnable is assigned its own unique ID.tags: string[] - The tags of the runnable that generated the event.metadata: Record<string, any> - The metadata of the runnable that generated the event.data: Record<string, any>Below is a table that illustrates some events that might be emitted by various chains. Metadata fields have been omitted from the table for brevity. Chain definitions have been included after the table.
ATTENTION This reference table is for the V2 version of the schema.
+----------------------+-----------------------------+------------------------------------------+
| event | input | output/chunk |
+======================+=============================+==========================================+
| on_chat_model_start | {"messages": BaseMessage[]} | |
+----------------------+-----------------------------+------------------------------------------+
| on_chat_model_stream | | AIMessageChunk("hello") |
+----------------------+-----------------------------+------------------------------------------+
| on_chat_model_end | {"messages": BaseMessage[]} | AIMessageChunk("hello world") |
+----------------------+-----------------------------+------------------------------------------+
| on_llm_start | {'input': 'hello'} | |
+----------------------+-----------------------------+------------------------------------------+
| on_llm_stream | | 'Hello' |
+----------------------+-----------------------------+------------------------------------------+
| on_llm_end | 'Hello human!' | |
+----------------------+-----------------------------+------------------------------------------+
| on_chain_start | | |
+----------------------+-----------------------------+------------------------------------------+
| on_chain_stream | | "hello world!" |
+----------------------+-----------------------------+------------------------------------------+
| on_chain_end | [Document(...)] | "hello world!, goodbye world!" |
+----------------------+-----------------------------+------------------------------------------+
| on_tool_start | {"x": 1, "y": "2"} | |
+----------------------+-----------------------------+------------------------------------------+
| on_tool_end | | {"x": 1, "y": "2"} |
+----------------------+-----------------------------+------------------------------------------+
| on_retriever_start | {"query": "hello"} | |
+----------------------+-----------------------------+------------------------------------------+
| on_retriever_end | {"query": "hello"} | [Document(...), ..] |
+----------------------+-----------------------------+------------------------------------------+
| on_prompt_start | {"question": "hello"} | |
+----------------------+-----------------------------+------------------------------------------+
| on_prompt_end | {"question": "hello"} | ChatPromptValue(messages: BaseMessage[]) |
+----------------------+-----------------------------+------------------------------------------+
The "on_chain_*" events are the default for Runnables that don't fit one of the above categories.
In addition to the standard events above, users can also dispatch custom events.
Custom events will be only be surfaced with in the v2 version of the API!
A custom event has following format:
+-----------+------+------------------------------------------------------------+
| Attribute | Type | Description |
+===========+======+============================================================+
| name | str | A user defined name for the event. |
+-----------+------+------------------------------------------------------------+
| data | Any | The data associated with the event. This can be anything. |
+-----------+------+------------------------------------------------------------+
Here's an example:
import { RunnableLambda } from "@langchain/core/runnables";
import { dispatchCustomEvent } from "@langchain/core/callbacks/dispatch";
// Use this import for web environments that don't support "async_hooks"
// and manually pass config to child runs.
// import { dispatchCustomEvent } from "@langchain/core/callbacks/dispatch/web";
const slowThing = RunnableLambda.from(async (someInput: string) => {
// Placeholder for some slow operation
await new Promise((resolve) => setTimeout(resolve, 100));
await dispatchCustomEvent("progress_event", {
message: "Finished step 1 of 2",
});
await new Promise((resolve) => setTimeout(resolve, 100));
return "Done";
});
const eventStream = await slowThing.streamEvents("hello world", {
version: "v2",
});
for await (const event of eventStream) {
if (event.event === "on_custom_event") {
console.log(event);
}
}