pycityagent 2.0.0a93__cp311-cp311-macosx_11_0_arm64.whl → 2.0.0a95__cp311-cp311-macosx_11_0_arm64.whl

pycityagent/environment/simulator.py

@@ -17,6 +17,7 @@ from pycityproto.city.person.v2 import person_service_pb2 as person_service
 from pymongo import MongoClient
 from shapely.geometry import Point
 
+from ..configs import SimConfig
 from .sim import CityClient, ControlSimEnv
 from .utils.const import *
 
@@ -29,19 +30,10 @@ __all__ = [
 
 @ray.remote
 class CityMap:
-    def __init__(self, mongo_input: tuple[str, str, str, str], map_cache_path: str):
-        if map_cache_path:
-            self.map = SimMap(
-                pb_path=map_cache_path,
-            )
-        else:
-            mongo_uri, mongo_db, mongo_coll, cache_dir = mongo_input
-            self.map = SimMap(
-                mongo_uri=mongo_uri,
-                mongo_db=mongo_db,
-                mongo_coll=mongo_coll,
-                cache_dir=cache_dir,
-            )
+    def __init__(self, map_cache_path: str):
+        self.map = SimMap(
+            pb_path=map_cache_path,
+        )
         self.poi_cate = POI_CATG_DICT
 
     def get_aoi(self, aoi_id: Optional[int] = None):
@@ -81,74 +73,41 @@ class Simulator:
         - It reads parameters from a configuration dictionary, initializes map data, and starts or connects to a simulation server as needed.
     """
 
-    def __init__(self, config: dict, create_map: bool = False) -> None:
-        self.config = config
+    def __init__(self, sim_config: SimConfig, create_map: bool = False) -> None:
+        self.sim_config = sim_config
         """
         - 模拟器配置
         - simulator config
         """
-        _map_request = config["map_request"]
-        if "file_path" not in _map_request:
-            # from mongo db
-            _mongo_uri, _mongo_db, _mongo_coll, _map_cache_dir = (
-                _map_request["mongo_uri"],
-                _map_request["mongo_db"],
-                _map_request["mongo_coll"],
-                _map_request["cache_dir"],
+        _map_pb_path = sim_config.prop_map_request.file_path
+        config = sim_config.prop_simulator_request
+        if not sim_config.prop_status.simulator_activated:
+            self._sim_env = sim_env = ControlSimEnv(
+                task_name=config.task_name,  # type:ignore
+                map_file=_map_pb_path,
+                max_day=config.max_day,  # type:ignore
+                start_step=config.start_step,  # type:ignore
+                total_step=config.total_step,  # type:ignore
+                log_dir=config.log_dir,  # type:ignore
+                min_step_time=config.min_step_time,  # type:ignore
+                primary_node_ip=config.primary_node_ip,  # type:ignore
+                sim_addr=sim_config.simulator_server_address,
             )
-            _mongo_client = MongoClient(_mongo_uri)
-            os.makedirs(_map_cache_dir, exist_ok=True)
-            _map_pb_path = os.path.join(_map_cache_dir, f"{_mongo_db}.{_mongo_coll}.pb")  # type: ignore
-            _map_pb = map_pb2.Map()
-            if os.path.exists(_map_pb_path):
-                with open(_map_pb_path, "rb") as f:
-                    _map_pb.ParseFromString(f.read())
-            else:
-                _map_pb = coll2pb(_mongo_client[_mongo_db][_mongo_coll], _map_pb)
-                with open(_map_pb_path, "wb") as f:
-                    f.write(_map_pb.SerializeToString())
-        else:
-            # from local file
-            _mongo_uri, _mongo_db, _mongo_coll, _map_cache_dir = "", "", "", ""
-            _map_pb_path = _map_request["file_path"]
-
-        if "simulator" in config:
-            if config["simulator"] is None:
-                config["simulator"] = {}
-            if not config["simulator"].get("_server_activated", False):
-                self._sim_env = sim_env = ControlSimEnv(
-                    task_name=config["simulator"].get("task", "citysim"),
-                    map_file=_map_pb_path,
-                    max_day=config["simulator"].get("max_day", 1000),
-                    start_step=config["simulator"].get("start_step", 28800),
-                    total_step=config["simulator"].get(
-                        "total_step", 24 * 60 * 60 * 365
-                    ),
-                    log_dir=config["simulator"].get("log_dir", "./log"),
-                    min_step_time=config["simulator"].get("min_step_time", 1000),
-                    primary_node_ip=config["simulator"].get("primary_node_ip", "localhost"),
-                    sim_addr=config["simulator"].get("server", None),
-                )
-                self.server_addr = sim_env.sim_addr
-                config["simulator"]["server"] = self.server_addr
-                config["simulator"]["_server_activated"] = True
-                # using local client
-                self._client = CityClient(
-                    sim_env.sim_addr, secure=self.server_addr.startswith("https")
-                )
-                """
-                - 模拟器grpc客户端
-                - grpc client of simulator
-                """
-            else:
-                self.server_addr = config["simulator"]["server"]
-                self._client = CityClient(
-                    self.server_addr, secure=self.server_addr.startswith("https")
-                )
+            self.server_addr = sim_env.sim_addr
+            sim_config.SetServerAddress(self.server_addr)
+            sim_config.prop_status.simulator_activated = True
+            # using local client
+            self._client = CityClient(
+                sim_env.sim_addr, secure=self.server_addr.startswith("https")
+            )
+            """
+            - 模拟器grpc客户端
+            - grpc client of simulator
+            """
         else:
-            self.server_addr = None
-            logger.warning(
-                "No simulator config found, no simulator client will be used"
+            self.server_addr: str = sim_config.simulator_server_address  # type:ignore
+            self._client = CityClient(
+                self.server_addr, secure=self.server_addr.startswith("https")
             )
         self._map = None
         """
@@ -157,7 +116,6 @@ class Simulator:
         """
         if create_map:
             self._map = CityMap.remote(
-                (_mongo_uri, _mongo_db, _mongo_coll, _map_cache_dir),
                 _map_pb_path,
             )
             self._create_poi_id_2_aoi_id()
@@ -205,8 +163,8 @@ class Simulator:
         """
         return self._environment_prompt
 
-    def get_server_addr(self):
-        return self.server_addr
+    def get_server_addr(self) -> str:
+        return self.server_addr  # type:ignore
 
     def set_environment(self, environment: dict[str, str]):
         """
@@ -239,41 +197,6 @@ class Simulator:
         """
         self._environment_prompt[key] = value
 
-    # * Agent相关
-    def find_agents_by_area(self, req: dict, status=None):
-        """
-        Find agents/persons within a specified area.
-
-        - **Args**:
-            - `req` (`dict`): A dictionary that describes the area. Refer to
-              https://cityproto.sim.fiblab.net/#city.person.1.GetPersonByLongLatBBoxRequest.
-            - `status` (`Optional[int]`): An integer representing the status of the agents/persons to filter by.
-              If provided, only persons with the given status will be returned.
-              Refer to https://cityproto.sim.fiblab.net/#city.agent.v2.Status.
-
-        - **Returns**:
-            - The response from the GetPersonByLongLatBBox method, possibly filtered by status.
-              Refer to https://cityproto.sim.fiblab.net/#city.person.1.GetPersonByLongLatBBoxResponse.
-        """
-        start_time = time.time()
-        log = {"req": "find_agents_by_area", "start_time": start_time, "consumption": 0}
-        loop = asyncio.get_event_loop()
-        resp = loop.run_until_complete(
-            self._client.person_service.GetPersonByLongLatBBox(req=req)
-        )
-        loop.close()
-        if status == None:
-            return resp
-        else:
-            motions = []
-            for agent in resp.motions:  # type: ignore
-                if agent.status in status:
-                    motions.append(agent)
-            resp.motions = motions  # type: ignore
-            log["consumption"] = time.time() - start_time
-            self._log_list.append(log)
-            return resp
-
     def get_poi_categories(
         self,
         center: Optional[Union[tuple[float, float], Point]] = None,

pycityagent/llm/__init__.py

@@ -1,11 +1,10 @@
 """LLM相关模块"""
 
 from .embeddings import SentenceEmbedding, SimpleEmbedding
-from .llm import LLM, LLMConfig
+from .llm import LLM
 
 __all__ = [
     "LLM",
-    "LLMConfig",
     "SentenceEmbedding",
     "SimpleEmbedding",
 ]

pycityagent/llm/llm.py

@@ -3,20 +3,15 @@
 import asyncio
 import json
 import logging
-import time
 import os
-from http import HTTPStatus
-from io import BytesIO
+import time
 from typing import Any, Optional, Union
 
-import dashscope
-import requests
-from dashscope import ImageSynthesis
 from openai import APIConnectionError, AsyncOpenAI, OpenAI, OpenAIError
-from PIL import Image
 from zhipuai import ZhipuAI
 
-from .llmconfig import *
+from ..configs import LLMRequestConfig
+from ..utils import LLMRequestType
 from .utils import *
 
 logging.getLogger("zhipuai").setLevel(logging.WARNING)
@@ -36,24 +31,24 @@ class LLM:
         - It initializes clients based on the specified request type and handles token usage and consumption reporting.
     """
 
-    def __init__(self, config: LLMConfig) -> None:
+    def __init__(self, config: LLMRequestConfig) -> None:
         """
         Initializes the LLM instance.
 
         - **Parameters**:
-            - `config`: An instance of `LLMConfig` containing configuration settings for the LLM.
+            - `config`: An instance of `LLMRequestConfig` containing configuration settings for the LLM.
         """
         self.config = config
-        if config.text["request_type"] not in ["openai", "deepseek", "qwen", "zhipuai"]:
+        if config.request_type not in {t.value for t in LLMRequestType}:
             raise ValueError("Invalid request type for text request")
         self.prompt_tokens_used = 0
         self.completion_tokens_used = 0
         self.request_number = 0
-        self.semaphore = None
+        self.semaphore = asyncio.Semaphore(200)
         self._current_client_index = 0
         self._log_list = []
 
-        api_keys = self.config.text["api_key"]
+        api_keys = self.config.api_key
         if not isinstance(api_keys, list):
             api_keys = [api_keys]
 
@@ -61,36 +56,40 @@ class LLM:
         self._client_usage = []
 
         for api_key in api_keys:
-            if self.config.text["request_type"] == "openai":
+            if self.config.request_type == LLMRequestType.OpenAI:
                 client = AsyncOpenAI(api_key=api_key, timeout=300)
-            elif self.config.text["request_type"] == "deepseek":
+            elif self.config.request_type == LLMRequestType.DeepSeek:
                 client = AsyncOpenAI(
                     api_key=api_key,
                     base_url="https://api.deepseek.com/v1",
                     timeout=300,
                 )
-            elif self.config.text["request_type"] == "qwen":
+            elif self.config.request_type == LLMRequestType.Qwen:
                 client = AsyncOpenAI(
                     api_key=api_key,
                     base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
                     timeout=300,
                 )
-            elif self.config.text["request_type"] == "zhipuai":
+            elif self.config.request_type == LLMRequestType.SiliconFlow:
+                client = AsyncOpenAI(
+                    api_key=api_key,
+                    base_url="https://api.siliconflow.cn/v1",
+                    timeout=300,
+                )
+            elif self.config.request_type == LLMRequestType.ZhipuAI:
                 client = ZhipuAI(api_key=api_key, timeout=300)
             else:
                 raise ValueError(
-                    f"Unsupported `request_type` {self.config.text['request_type']}!"
+                    f"Unsupported `request_type` {self.config.request_type}!"
                 )
             self._aclients.append(client)
-            self._client_usage.append({
-                "prompt_tokens": 0,
-                "completion_tokens": 0,
-                "request_number": 0
-            })
+            self._client_usage.append(
+                {"prompt_tokens": 0, "completion_tokens": 0, "request_number": 0}
+            )
 
     def get_log_list(self):
         return self._log_list
-    
+
     def clear_log_list(self):
         self._log_list = []
 
@@ -116,7 +115,7 @@ class LLM:
         """
         for usage in self._client_usage:
             usage["prompt_tokens"] = 0
-            usage["completion_tokens"] = 0 
+            usage["completion_tokens"] = 0
             usage["request_number"] = 0
 
     def get_consumption(self):
@@ -124,7 +123,7 @@ class LLM:
         for i, usage in enumerate(self._client_usage):
             consumption[f"api-key-{i+1}"] = {
                 "total_tokens": usage["prompt_tokens"] + usage["completion_tokens"],
-                "request_number": usage["request_number"]
+                "request_number": usage["request_number"],
             }
         return consumption
 
@@ -141,27 +140,24 @@ class LLM:
         - **Returns**:
             - A dictionary summarizing the token usage and, if applicable, the estimated cost.
         """
-        total_stats = {
-            "total": 0,
-            "prompt": 0,
-            "completion": 0,
-            "requests": 0
-        }
-        
+        total_stats = {"total": 0, "prompt": 0, "completion": 0, "requests": 0}
+
         for i, usage in enumerate(self._client_usage):
             prompt_tokens = usage["prompt_tokens"]
             completion_tokens = usage["completion_tokens"]
             requests = usage["request_number"]
             total_tokens = prompt_tokens + completion_tokens
-            
+
             total_stats["total"] += total_tokens
             total_stats["prompt"] += prompt_tokens
             total_stats["completion"] += completion_tokens
             total_stats["requests"] += requests
-            
-            rate = prompt_tokens / completion_tokens if completion_tokens != 0 else "nan"
+
+            rate = (
+                prompt_tokens / completion_tokens if completion_tokens != 0 else "nan"
+            )
             tokens_per_request = total_tokens / requests if requests != 0 else "nan"
-            
+
             print(f"\nAPI Key #{i+1}:")
             print(f"Request Number: {requests}")
             print("Token Usage:")
@@ -170,12 +166,14 @@ class LLM:
             print(f"    - Completion tokens: {completion_tokens}")
             print(f"    - Token per request: {tokens_per_request}")
             print(f"    - Prompt:Completion ratio: {rate}:1")
-            
+
             if input_price is not None and output_price is not None:
-                consumption = (prompt_tokens / 1000000 * input_price + 
-                             completion_tokens / 1000000 * output_price)
+                consumption = (
+                    prompt_tokens / 1000000 * input_price
+                    + completion_tokens / 1000000 * output_price
+                )
                 print(f"    - Cost Estimation: {consumption}")
-        
+
         return total_stats
 
     def _get_next_client(self):
@@ -197,6 +195,7 @@ class LLM:
     async def atext_request(
         self,
         dialog: Any,
+        response_format: Optional[dict[str, Any]] = None,
         temperature: float = 1,
         max_tokens: Optional[int] = None,
         top_p: Optional[float] = None,
@@ -216,6 +215,7 @@ class LLM:
 
         - **Parameters**:
             - `dialog`: Messages to send as part of the chat completion request.
+            - `response_format`: JSON schema for the response. Default is None.
             - `temperature`: Controls randomness in the model's output. Default is 1.
             - `max_tokens`: Maximum number of tokens to generate in the response. Default is None.
             - `top_p`: Limits the next token selection to a subset of tokens with a cumulative probability above this value. Default is None.
@@ -232,18 +232,23 @@ class LLM:
         """
         start_time = time.time()
         log = {"request_time": start_time}
+        assert (
+            self.semaphore is not None
+        ), "Please set semaphore with `set_semaphore` first!"
         async with self.semaphore:
             if (
-                self.config.text["request_type"] == "openai"
-                or self.config.text["request_type"] == "deepseek"
-                or self.config.text["request_type"] == "qwen"
+                self.config.request_type == "openai"
+                or self.config.request_type == "deepseek"
+                or self.config.request_type == "qwen"
+                or self.config.request_type == "siliconflow"
             ):
                 for attempt in range(retries):
                     try:
                         client = self._get_next_client()
                         response = await client.chat.completions.create(
-                            model=self.config.text["model"],
+                            model=self.config.model,
                             messages=dialog,
+                            response_format=response_format,
                             temperature=temperature,
                             max_tokens=max_tokens,
                             top_p=top_p,
@@ -256,7 +261,9 @@ class LLM:
                         )  # type: ignore
                         self._client_usage[self._current_client_index]["prompt_tokens"] += response.usage.prompt_tokens  # type: ignore
                         self._client_usage[self._current_client_index]["completion_tokens"] += response.usage.completion_tokens  # type: ignore
-                        self._client_usage[self._current_client_index]["request_number"] += 1
+                        self._client_usage[self._current_client_index][
+                            "request_number"
+                        ] += 1
                         end_time = time.time()
                         log["consumption"] = end_time - start_time
                         log["input_tokens"] = response.usage.prompt_tokens
@@ -288,16 +295,15 @@ class LLM:
                     except Exception as e:
                         print("LLM Error (OpenAI):", e)
                         if attempt < retries - 1:
-                            print(dialog)
                             await asyncio.sleep(2**attempt)
                         else:
                             raise e
-            elif self.config.text["request_type"] == "zhipuai":
+            elif self.config.request_type == "zhipuai":
                 for attempt in range(retries):
                     try:
                         client = self._get_next_client()
                         response = client.chat.asyncCompletions.create(  # type: ignore
-                            model=self.config.text["model"],
+                            model=self.config.model,
                             messages=dialog,
                             temperature=temperature,
                             top_p=top_p,
@@ -323,10 +329,12 @@ class LLM:
 
                         self._client_usage[self._current_client_index]["prompt_tokens"] += result_response.usage.prompt_tokens  # type: ignore
                         self._client_usage[self._current_client_index]["completion_tokens"] += result_response.usage.completion_tokens  # type: ignore
-                        self._client_usage[self._current_client_index]["request_number"] += 1
+                        self._client_usage[self._current_client_index][
+                            "request_number"
+                        ] += 1
                         end_time = time.time()
                         log["used_time"] = end_time - start_time
-                        log["token_consumption"] = result_response.usage.prompt_tokens + result_response.usage.completion_tokens
+                        log["token_consumption"] = result_response.usage.prompt_tokens + result_response.usage.completion_tokens  # type: ignore
                         self._log_list.append(log)
                         if tools and result_response.choices[0].message.tool_calls:  # type: ignore
                             return json.loads(
@@ -349,118 +357,4 @@ class LLM:
                         else:
                             raise e
             else:
-                print("ERROR: Wrong Config")
-                return "wrong config"
-
-    async def img_understand(
-        self, img_path: Union[str, list[str]], prompt: Optional[str] = None
-    ) -> str:
-        """
-        Analyzes and understands images using external APIs.
-
-        - **Args**:
-            img_path (Union[str, list[str]]): Path or list of paths to the images for analysis.
-            prompt (Optional[str]): Guidance text for understanding the images.
-
-        - **Returns**:
-            str: The content derived from understanding the images.
-        """
-        ppt = "如何理解这幅图像？"
-        if prompt != None:
-            ppt = prompt
-        if self.config.image_u["request_type"] == "openai":
-            if "api_base" in self.config.image_u.keys():
-                api_base = self.config.image_u["api_base"]
-            else:
-                api_base = None
-            client = OpenAI(
-                api_key=self.config.text["api_key"],
-                base_url=api_base,
-            )
-            content = []
-            content.append({"type": "text", "text": ppt})
-            if isinstance(img_path, str):
-                base64_image = encode_image(img_path)
-                content.append(
-                    {
-                        "type": "image_url",
-                        "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"},
-                    }
-                )
-            elif isinstance(img_path, list) and all(
-                isinstance(item, str) for item in img_path
-            ):
-                for item in img_path:
-                    base64_image = encode_image(item)
-                    content.append(
-                        {
-                            "type": "image_url",
-                            "image_url": {
-                                "url": f"data:image/jpeg;base64,{base64_image}"
-                            },
-                        }
-                    )
-            response = client.chat.completions.create(
-                model=self.config.image_u["model"],
-                messages=[{"role": "user", "content": content}],
-            )
-            return response.choices[0].message.content  # type: ignore
-        elif self.config.image_u["request_type"] == "qwen":
-            content = []
-            if isinstance(img_path, str):
-                content.append({"image": "file://" + img_path})
-                content.append({"text": ppt})
-            elif isinstance(img_path, list) and all(
-                isinstance(item, str) for item in img_path
-            ):
-                for item in img_path:
-                    content.append({"image": "file://" + item})
-                content.append({"text": ppt})
-
-            dialog = [{"role": "user", "content": content}]
-            response = dashscope.MultiModalConversation.call(
-                model=self.config.image_u["model"],
-                api_key=self.config.image_u["api_key"],
-                messages=dialog,
-            )
-            if response.status_code == HTTPStatus.OK:  # type: ignore
-                return response.output.choices[0]["message"]["content"]  # type: ignore
-            else:
-                print(response.code)  # type: ignore # The error code.
-                return "Error"
-        else:
-            print(
-                "ERROR: wrong image understanding type, only 'openai' and 'openai' is available"
-            )
-            return "Error"
-
-    async def img_generate(self, prompt: str, size: str = "512*512", quantity: int = 1):
-        """
-        Generates images based on a given prompt.
-
-        - **Args**:
-            prompt (str): Prompt for generating images.
-            size (str): Size of the generated images, default is '512*512'.
-            quantity (int): Number of images to generate, default is 1.
-
-        - **Returns**:
-            list[PIL.Image.Image]: List of generated PIL Image objects.
-        """
-        rsp = ImageSynthesis.call(
-            model=self.config.image_g["model"],
-            api_key=self.config.image_g["api_key"],
-            prompt=prompt,
-            n=quantity,
-            size=size,
-        )
-        if rsp.status_code == HTTPStatus.OK:
-            res = []
-            for result in rsp.output.results:
-                res.append(Image.open(BytesIO(requests.get(result.url).content)))
-            return res
-        else:
-            print(
-                "Failed, status_code: %s, code: %s, message: %s"
-                % (rsp.status_code, rsp.code, rsp.message)
-            )
-            return None
+                raise ValueError("ERROR: Wrong Config")

pycityagent/memory/memory.py

@@ -335,9 +335,7 @@ class StreamMemory:
             )
         return "\n".join(formatted_results)
 
-    async def get_by_ids(
-        self, memory_ids: Union[int, list[int]]
-    ) -> Coroutine[Any, Any, str]:
+    async def get_by_ids(self, memory_ids: Union[int, list[int]]) -> str:
         """获取指定ID的记忆"""
         memories = [memory for memory in self._memories if memory.id in memory_ids]
         sorted_results = sorted(memories, key=lambda x: (x.day, x.t), reverse=True)
@@ -491,15 +489,18 @@ class StreamMemory:
         - **Returns**:
             - `list[dict]`: List of all memory nodes as dictionaries.
         """
-        return [{
-            "id": memory.id,
-            "cognition_id": memory.cognition_id,
-            "tag": memory.tag.value,
-            "location": memory.location,
-            "description": memory.description,
-            "day": memory.day,
-            "t": memory.t,
-        } for memory in self._memories]
+        return [
+            {
+                "id": memory.id,
+                "cognition_id": memory.cognition_id,
+                "tag": memory.tag.value,
+                "location": memory.location,
+                "description": memory.description,
+                "day": memory.day,
+                "t": memory.t,
+            }
+            for memory in self._memories
+        ]
 
 
 class StatusMemory:

pycityagent/message/message_interceptor.py

@@ -10,7 +10,8 @@ from typing import Any, Optional, Union
 import ray
 from ray.util.queue import Queue
 
-from ..llm import LLM, LLMConfig
+from ..configs import LLMRequestConfig
+from ..llm import LLM
 from ..utils.decorators import lock_decorator
 
 DEFAULT_ERROR_STRING = """
@@ -95,7 +96,7 @@ class MessageInterceptor:
         self,
         blocks: Optional[list[MessageBlockBase]] = None,
         black_list: Optional[list[tuple[str, str]]] = None,
-        llm_config: Optional[dict] = None,
+        llm_config: Optional[LLMRequestConfig] = None,
         queue: Optional[Queue] = None,
     ) -> None:
         """
@@ -104,7 +105,7 @@ class MessageInterceptor:
         - **Args**:
             - `blocks` (Optional[list[MessageBlockBase]], optional): Initial list of message interception rules. Defaults to an empty list.
             - `black_list` (Optional[list[tuple[str, str]]], optional): Initial blacklist of communication pairs. Defaults to an empty list.
-            - `llm_config` (Optional[dict], optional): Configuration dictionary for initializing the LLM instance. Defaults to None.
+            - `llm_config` (Optional[LLMRequestConfig], optional): Configuration dictionary for initializing the LLM instance. Defaults to None.
             - `queue` (Optional[Queue], optional): Queue for message processing. Defaults to None.
         """
         if blocks is not None:
@@ -119,7 +120,7 @@ class MessageInterceptor:
                 []
             )  # list[tuple(from_uuid, to_uuid)] `None` means forbidden for everyone.
         if llm_config:
-            self._llm = LLM(LLMConfig(llm_config))
+            self._llm = LLM(llm_config)
         else:
             self._llm = None
         self._queue = queue