Skip to content

LLMConfig

autogen.LLMConfig #

LLMConfig(*configs, top_p=None, temperature=None, max_tokens=None, check_every_ms=None, allow_format_str_template=None, response_format=None, timeout=None, seed=None, cache_seed=None, parallel_tool_calls=None, tools=(), functions=(), routing_method=None)

Initializes the LLMConfig object.

PARAMETER DESCRIPTION
*configs

A list of LLM configuration entries or dictionaries.

TYPE: ConfigItem DEFAULT: ()

temperature

The sampling temperature for LLM generation.

TYPE: float | None DEFAULT: None

check_every_ms

The interval (in milliseconds) to check for updates

TYPE: int | None DEFAULT: None

allow_format_str_template

Whether to allow format string templates.

TYPE: bool | None DEFAULT: None

response_format

The format of the response (e.g., JSON, text).

TYPE: str | dict[str, Any] | BaseModel | type[BaseModel] | None DEFAULT: None

timeout

The timeout for LLM requests in seconds.

TYPE: int | None DEFAULT: None

seed

The random seed for reproducible results.

TYPE: int | None DEFAULT: None

cache_seed

The seed for caching LLM responses.

TYPE: int | None DEFAULT: None

parallel_tool_calls

Whether to enable parallel tool calls.

TYPE: bool | None DEFAULT: None

tools

A list of tools available for the LLM.

TYPE: Iterable[Any] DEFAULT: ()

functions

A list of functions available for the LLM.

TYPE: Iterable[Any] DEFAULT: ()

max_tokens

The maximum number of tokens to generate.

TYPE: int | None DEFAULT: None

top_p

The nucleus sampling probability.

TYPE: float | None DEFAULT: None

routing_method

The method used to route requests (e.g., fixed_order, round_robin).

TYPE: Literal['fixed_order', 'round_robin'] | None DEFAULT: None

Examples:

# Example 1: create config from one model dictionary
config = LLMConfig({
    "model": "gpt-5-mini",
    "api_key": os.environ["OPENAI_API_KEY"],
})

# Example 2: create config from list of dictionaries
config = LLMConfig(
    {
        "model": "gpt-5-mini",
        "api_key": os.environ["OPENAI_API_KEY"],
    },
    {
        "model": "gpt-4",
        "api_key": os.environ["OPENAI_API_KEY"],
    },
)
Source code in autogen/llm_config/config.py 
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
def __init__(
    self,
    *configs: ConfigItem,
    top_p: float | None = None,
    temperature: float | None = None,
    max_tokens: int | None = None,
    check_every_ms: int | None = None,
    allow_format_str_template: bool | None = None,
    response_format: str | dict[str, Any] | BaseModel | type[BaseModel] | None = None,
    timeout: int | None = None,
    seed: int | None = None,
    cache_seed: int | None = None,
    parallel_tool_calls: bool | None = None,
    tools: Iterable[Any] = (),
    functions: Iterable[Any] = (),
    routing_method: Literal["fixed_order", "round_robin"] | None = None,
) -> None:
    r"""Initializes the LLMConfig object.

    Args:
        *configs: A list of LLM configuration entries or dictionaries.
        temperature: The sampling temperature for LLM generation.
        check_every_ms: The interval (in milliseconds) to check for updates
        allow_format_str_template: Whether to allow format string templates.
        response_format: The format of the response (e.g., JSON, text).
        timeout: The timeout for LLM requests in seconds.
        seed: The random seed for reproducible results.
        cache_seed: The seed for caching LLM responses.
        parallel_tool_calls: Whether to enable parallel tool calls.
        tools: A list of tools available for the LLM.
        functions: A list of functions available for the LLM.
        max_tokens: The maximum number of tokens to generate.
        top_p: The nucleus sampling probability.
        routing_method: The method used to route requests (e.g., fixed_order, round_robin).

    Examples:
        ```python
        # Example 1: create config from one model dictionary
        config = LLMConfig({
            "model": "gpt-5-mini",
            "api_key": os.environ["OPENAI_API_KEY"],
        })

        # Example 2: create config from list of dictionaries
        config = LLMConfig(
            {
                "model": "gpt-5-mini",
                "api_key": os.environ["OPENAI_API_KEY"],
            },
            {
                "model": "gpt-4",
                "api_key": os.environ["OPENAI_API_KEY"],
            },
        )
        ```
    """
    app_config = ApplicationConfig(
        max_tokens=max_tokens,
        top_p=top_p,
        temperature=temperature,
    )

    application_level_options = app_config.model_dump(exclude_none=True)

    final_config_list: list[LLMConfigEntry | dict[str, Any]] = []
    for c in filter(bool, configs):
        if isinstance(c, LLMConfigEntry):
            final_config_list.append(c.apply_application_config(app_config))
            continue

        else:
            final_config_list.append({
                "api_type": "openai",  # default api_type
                **application_level_options,
                **c,
            })
    self._model = _LLMConfig(
        **application_level_options,
        config_list=final_config_list,
        check_every_ms=check_every_ms,
        seed=seed,
        allow_format_str_template=allow_format_str_template,
        response_format=response_format,
        timeout=timeout,
        cache_seed=cache_seed,
        tools=tools or [],
        functions=functions or [],
        parallel_tool_calls=parallel_tool_calls,
        routing_method=routing_method,
    )

config_list instance-attribute #

config_list

ensure_config classmethod #

ensure_config(config)

Transforms passed objects to LLMConfig object.

Method to use for Agent(llm_config={...}) cases.

LLMConfig.ensure_config(LLMConfig(...)) LLMConfig(...)

LLMConfig.ensure_config(LLMConfigEntry(...)) LLMConfig(LLMConfigEntry(...))

LLMConfig.ensure_config({"model": "gpt-o3"}) LLMConfig(OpenAILLMConfigEntry(model="o3"))

LLMConfig.ensure_config([{"model": "gpt-o3"}, ...]) LLMConfig(OpenAILLMConfigEntry(model="o3"), ...)

(deprecated) LLMConfig.ensure_config({"config_list": [{ "model": "gpt-o3" }, ...]}) LLMConfig(OpenAILLMConfigEntry(model="o3"), ...)

Source code in autogen/llm_config/config.py 
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
@classmethod
def ensure_config(cls, config: "LLMConfig | ConfigItem | Iterable[ConfigItem]", /) -> "LLMConfig":
    """Transforms passed objects to LLMConfig object.

    Method to use for `Agent(llm_config={...})` cases.

    >>> LLMConfig.ensure_config(LLMConfig(...))
    LLMConfig(...)

    >>> LLMConfig.ensure_config(LLMConfigEntry(...))
    LLMConfig(LLMConfigEntry(...))

    >>> LLMConfig.ensure_config({"model": "gpt-o3"})
    LLMConfig(OpenAILLMConfigEntry(model="o3"))

    >>> LLMConfig.ensure_config([{"model": "gpt-o3"}, ...])
    LLMConfig(OpenAILLMConfigEntry(model="o3"), ...)

    >>> (deprecated) LLMConfig.ensure_config({"config_list": [{ "model": "gpt-o3" }, ...]})
    LLMConfig(OpenAILLMConfigEntry(model="o3"), ...)
    """
    if isinstance(config, LLMConfig):
        return config.copy()

    if isinstance(config, LLMConfigEntry):
        return LLMConfig(config)

    if isinstance(config, dict):
        if "config_list" in config:  # backport compatibility
            config_list = config.pop("config_list")
            if isinstance(config_list, dict):
                config_list = [config_list]
            return LLMConfig(*config_list, **config)
        return LLMConfig(config)

    return LLMConfig(*config)

from_json classmethod #

from_json(*, env=None, path=None, file_location=None, filter_dict=None, **kwargs)
Source code in autogen/llm_config/config.py 
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
@classmethod
def from_json(
    cls,
    *,
    env: str | None = None,
    path: str | Path | None = None,
    file_location: str | None = None,
    filter_dict: dict[str, list[str | None] | set[str | None]] | None = None,
    **kwargs: Any,
) -> Self:
    if env is None and path is None:
        raise ValueError("Either 'env' or 'path' must be provided")

    if env is not None and path is not None:
        raise ValueError("Only one of 'env' or 'path' can be provided")

    config_list = config_list_from_json(
        env_or_file=env if env is not None else str(path),
        file_location=file_location,
        filter_dict=filter_dict,
    )

    return cls(*config_list, **kwargs)

where #

where(*, exclude=False, **kwargs)
Source code in autogen/llm_config/config.py 
180
181
182
183
184
185
186
187
188
189
190
191
192
def where(self, *, exclude: bool = False, **kwargs: Any) -> "LLMConfig":
    filtered_config_list = filter_config(
        config_list=[c.model_dump() for c in self.config_list],
        filter_dict=kwargs,
        exclude=exclude,
    )

    if len(filtered_config_list) == 0:
        raise ValueError(f"No config found that satisfies the filter criteria: {kwargs}")

    kwargs = self.model_dump()
    del kwargs["config_list"]
    return LLMConfig(*filtered_config_list, **kwargs)

model_dump #

model_dump(*args, exclude_none=True, **kwargs)
Source code in autogen/llm_config/config.py 
194
195
196
def model_dump(self, *args: Any, exclude_none: bool = True, **kwargs: Any) -> dict[str, Any]:
    d = self._model.model_dump(*args, exclude_none=exclude_none, **kwargs)
    return {k: v for k, v in d.items() if not (isinstance(v, list) and len(v) == 0)}

model_dump_json #

model_dump_json(*args, exclude_none=True, **kwargs)
Source code in autogen/llm_config/config.py 
198
199
200
201
def model_dump_json(self, *args: Any, exclude_none: bool = True, **kwargs: Any) -> str:
    # return self._model.model_dump_json(*args, exclude_none=exclude_none, **kwargs)
    d = self.model_dump(*args, exclude_none=exclude_none, **kwargs)
    return json.dumps(d)

model_validate #

model_validate(*args, **kwargs)
Source code in autogen/llm_config/config.py 
203
204
def model_validate(self, *args: Any, **kwargs: Any) -> Any:
    return self._model.model_validate(*args, **kwargs)

model_validate_json #

model_validate_json(*args, **kwargs)
Source code in autogen/llm_config/config.py 
206
207
208
@functools.wraps(BaseModel.model_validate_json)
def model_validate_json(self, *args: Any, **kwargs: Any) -> Any:
    return self._model.model_validate_json(*args, **kwargs)

model_validate_strings #

model_validate_strings(*args, **kwargs)
Source code in autogen/llm_config/config.py 
210
211
212
@functools.wraps(BaseModel.model_validate_strings)
def model_validate_strings(self, *args: Any, **kwargs: Any) -> Any:
    return self._model.model_validate_strings(*args, **kwargs)

get #

get(key, default=None)
Source code in autogen/llm_config/config.py 
223
224
225
def get(self, key: str, default: Any | None = None) -> Any:
    val = getattr(self._model, key, default)
    return val

copy #

copy()
Source code in autogen/llm_config/config.py 
272
273
def copy(self) -> "LLMConfig":
    return self.__copy__()

deepcopy #

deepcopy(memo=None)
Source code in autogen/llm_config/config.py 
275
276
def deepcopy(self, memo: dict[int, Any] | None = None) -> "LLMConfig":
    return self.__deepcopy__(memo)

items #

items()
Source code in autogen/llm_config/config.py 
281
282
283
def items(self) -> Iterable[tuple[str, Any]]:
    d = self.model_dump()
    return d.items()

keys #

keys()
Source code in autogen/llm_config/config.py 
285
286
287
def keys(self) -> Iterable[str]:
    d = self.model_dump()
    return d.keys()

values #

values()
Source code in autogen/llm_config/config.py 
289
290
291
def values(self) -> Iterable[Any]:
    d = self.model_dump()
    return d.values()