大模型Agent性能优化：LLMCompiler架构设计与实现（必学收藏）

关注

原创最新推荐文章于 2026-11-10 16:31:25 发布 724 阅读 AI 写同款· GEO 优化 ›

AI Agent工程化：核心挑战与优化实践 AI Agent作为大模型落地的关键技术载体，通过感知-决策-执行闭环系统将LLM认知能力转化为生产力。其核心原理在于任务分解与工具调用，但在工程实践中面临规划能力、工具可靠性、记忆系统等挑战。通过引入ReAct模式优化、动态重规划机制等解决方案，可显著提升复杂任务处理效率。在电商客服、医疗问诊等场景中，结合提示词压缩、混合记忆系统等技术，AI Agent的准确率和响应速度得到明显改善。当前技术演进正从基础问答向复杂问题求解发展，Plan and Solve等进阶模式在智能运维等领域展现出89%的实践准确率阅读详情

随着大语言模型在复杂任务处理中的应用日益广泛，如何提高Agent系统的执行效率和降低计算成本成为了关键挑战。本文介绍了LLMCompiler架构的实现，创新Agent设计，旨在通过并行执行任务和减少冗余的LLM调用来提升性能。我们使用LangGraph框架完整实现了这一架构，并通过多个实际案例验证了其有效性。

1. 引言

传统的AI Agent系统往往采用串行执行方式，每个任务必须等待前一个任务完成才能开始执行。这种设计不仅导致了执行时间的延长，还产生了大量的冗余计算成本。LLMCompiler通过引入有向无环图（DAG）的任务调度机制，实现了任务的并行化执行，显著提升了系统性能。

2. LLMCompiler架构概述

LLMCompiler架构包含三个核心组件：

2.1 规划器（Planner）

规划器负责将用户查询转换为可执行的任务DAG。它分析查询需求，识别可以并行执行的任务，并生成结构化的执行计划。

2.2 任务获取单元（Task Fetching Unit）

任务获取单元负责任务的调度和执行。一旦任务的依赖关系得到满足，它就会立即开始执行相应的任务，从而实现最大程度的并行化。

2.3 连接器（Joiner）

连接器处理任务执行的结果，决定是直接向用户提供最终答案，还是需要触发新一轮的规划和执行。

3. 系统实现

3.1 环境配置与工具定义

首先，我们需要安装必要的依赖包并配置API密钥：

%%capture --no-stderr%pip install -U --quiet langchain_openai langsmith langgraph langchain numexprimport getpassimport osdef _get_pass(var:str):if var notin os.environ:        os.environ[var]= getpass.getpass(f"{var}: ")_get_pass("OPENAI_API_KEY")_get_pass("TAVILY_API_KEY")```

接下来定义系统使用的核心工具：

from langchain_community.tools.tavily_search import TavilySearchResultsfrom langchain_openai import ChatOpenAIfrom math_tools import get_math_tool# 创建数学计算工具calculate = get_math_tool(ChatOpenAI(model="gpt-4o"))# 创建搜索工具search = TavilySearchResults(    max_results=1,    description='tavily_search_results_json(query="the search query") - a search engine.',)tools = [search, calculate]# 测试数学工具calculate.invoke(    {        "problem": "What's the temp of sf + 5?",        "context": ["The temperature of sf is 32 degrees"],    })# 输出: '37'

系统使用了两个核心工具：Tavily搜索引擎用于信息检索，数学计算工具用于处理数值计算任务。这种工具组合为系统提供了处理复杂查询的基础能力。

3.2 规划器实现

规划器采用了专门设计的提示模板，能够将用户查询解析为标准化的任务序列。首先导入必要的模块：

from typing import Sequencefrom langchain import hubfrom langchain_core.language_models import BaseChatModelfrom langchain_core.messages import(    BaseMessage,    FunctionMessage,    HumanMessage,    SystemMessage,)from langchain_core.prompts import ChatPromptTemplatefrom langchain_core.runnables import RunnableBranchfrom langchain_core.tools import BaseToolfrom langchain_openai import ChatOpenAIfrom output_parser import LLMCompilerPlanParser, Task

获取并检查提示模板：

prompt = hub.pull("wfh/llm-compiler")print(prompt.pretty_print())# 输出显示提示模板的内容，包含系统消息和任务格式说明

创建规划器函数的完整实现：

defcreate_planner(    llm: BaseChatModel, tools: Sequence[BaseTool], base_prompt: ChatPromptTemplate):    tool_descriptions ="\n".join(f"{i +1}. {tool.description}\n"for i, tool inenumerate(            tools        )# +1 to offset the 0 starting index, we want it count normally from 1.    )    planner_prompt = base_prompt.partial(        replan="",        num_tools=len(tools)        + 1,  # Add one because we're adding the join() tool at the end.        tool_descriptions=tool_descriptions,    )    replanner_prompt = base_prompt.partial(        replan=' - You are given "Previous Plan" which is the plan that the previous agent created along with the execution results '        "(given as Observation) of each plan and a general thought (given as Thought) about the executed results."        'You MUST use these information to create the next plan under "Current Plan".\n'        ' - When starting the Current Plan, you should start with "Thought" that outlines the strategy for the next plan.\n'        " - In the Current Plan, you should NEVER repeat the actions that are already executed in the Previous Plan.\n"        " - You must continue the task index from the end of the previous one. Do not repeat task indices.",        num_tools=len(tools) + 1,        tool_descriptions=tool_descriptions,    )    def should_replan(state: list):        # Context is passed as a system message        return isinstance(state[-1], SystemMessage)    def wrap_messages(state: list):        return {"messages": state}    def wrap_and_get_last_index(state: list):        next_task = 0        for message in state[::-1]:            if isinstance(message, FunctionMessage):                next_task = message.additional_kwargs["idx"] + 1                break        state[-1].content = state[-1].content + f" - Begin counting at : {next_task}"        return {"messages": state}    return (        RunnableBranch(            (should_replan, wrap_and_get_last_index | replanner_prompt),            wrap_messages | planner_prompt,        )        | llm        | LLMCompilerPlanParser(tools=tools)    )# 创建规划器实例llm = ChatOpenAI(model="gpt-4-turbo-preview")planner = create_planner(llm, tools, prompt)

测试规划器功能：

example_question ="What's the temperature in SF raised to the 3rd power?"for task in planner.stream([HumanMessage(content=example_question)]):print(task["tool"], task["args"])print("---")# 输出：# description='tavily_search_results_json(query="the search query") - a search engine.' max_results=1 {'query': 'current temperature in San Francisco'}# ---# name='math' description='math(problem: str, context: Optional[list[str]]) -> float:...' {'problem': 'x ** 3', 'context': ['$1']}# ---# join ()# ---

任务格式如下：

1. tool_1(arg1="arg1", arg2=3.5, ...)Thought: I then want to find out Y by using tool_22. tool_2(arg1="", arg2="${1}")3. join()<END_OF_PLAN>

其中${#}占位符用于表示任务间的依赖关系，实现了任务输出的自动路由。

这个例子展示了规划器如何识别任务间的依赖关系，并生成合适的执行序列。

3.3 任务调度与执行系统

任务调度系统是LLMCompiler的核心创新之一。它使用多线程技术实现任务的并发执行，一旦任务的依赖条件满足就立即开始执行。

首先导入必要的模块：

import reimport timefrom concurrent.futures import ThreadPoolExecutor, waitfrom typing import Any, Dict, Iterable, List, Unionfrom langchain_core.runnables import(    chain as as_runnable,)from typing_extensions import TypedDict

定义核心数据结构和辅助函数：

def_get_observations(messages: List[BaseMessage])-> Dict[int, Any]:# Get all previous tool responses    results = {}    for message in messages[::-1]:        if isinstance(message, FunctionMessage):            results[int(message.additional_kwargs["idx"])] = message.content    return resultsclass SchedulerInput(TypedDict):    messages: List[BaseMessage]    tasks: Iterable[Task]

实现任务执行函数：

def_execute_task(task, observations, config):    tool_to_use = task["tool"]ifisinstance(tool_to_use,str):return tool_to_use    args = task["args"]try:ifisinstance(args,str):            resolved_args = _resolve_arg(args, observations)elifisinstance(args,dict):            resolved_args ={                key: _resolve_arg(val, observations)for key, val in args.items()}else:# This will likely fail            resolved_args = args    except Exception as e:        return (            f"ERROR(Failed to call {tool_to_use.name} with args {args}.)"            f" Args could not be resolved. Error: {repr(e)}"        )    try:        return tool_to_use.invoke(resolved_args, config)    except Exception as e:        return (            f"ERROR(Failed to call {tool_to_use.name} with args {args}."            + f" Args resolved to {resolved_args}. Error: {repr(e)})"        )def _resolve_arg(arg: Union[str, Any], observations: Dict[int, Any]):    # $1 or ${1} -> 1    ID_PATTERN = r"\$\{?(\d+)\}?"    def replace_match(match):        # If the string is ${123}, match.group(0) is ${123}, and match.group(1) is 123.        # Return the match group, in this case the index, from the string. This is the index        # number we get back.        idx = int(match.group(1))        return str(observations.get(idx, match.group(0)))    # For dependencies on other tasks    if isinstance(arg, str):        return re.sub(ID_PATTERN, replace_match, arg)    elif isinstance(arg, list):        return [_resolve_arg(a, observations) for a in arg]    else:        return str(arg)

实现任务调度函数：

@as_runnabledef schedule_task(task_inputs, config):    task: Task = task_inputs["task"]    observations: Dict[int, Any]= task_inputs["observations"]try:        observation = _execute_task(task, observations, config)except Exception:import traceback        observation = traceback.format_exception()# repr(e) +    observations[task["idx"]] = observationdef schedule_pending_task(    task: Task, observations: Dict[int, Any], retry_after: float = 0.2):    while True:        deps = task["dependencies"]        if deps and (any([dep not in observations for dep in deps])):            # Dependencies not yet satisfied            time.sleep(retry_after)            continue        schedule_task.invoke({"task": task, "observations": observations})        break@as_runnabledef schedule_tasks(scheduler_input: SchedulerInput) -> List[FunctionMessage]:    """Group the tasks into a DAG schedule."""    tasks = scheduler_input["tasks"]    args_for_tasks = {}    messages = scheduler_input["messages"]    # If we are re-planning, we may have calls that depend on previous    # plans. Start with those.    observations = _get_observations(messages)    task_names = {}    originals = set(observations)    # ^^ We assume each task inserts a different key above to    # avoid race conditions...    futures = []    retry_after = 0.25  # Retry every quarter second    with ThreadPoolExecutor() as executor:        for task in tasks:            deps = task["dependencies"]            task_names[task["idx"]] = (                task["tool"] if isinstance(task["tool"], str) else task["tool"].name            )            args_for_tasks[task["idx"]] = task["args"]            if (                # Depends on other tasks                deps and (any([dep not in observations for dep in deps]))            ):                futures.append(                    executor.submit(                        schedule_pending_task, task, observations, retry_after                    )                )            else:                # No deps or all deps satisfied                # can schedule now                schedule_task.invoke(dict(task=task, observations=observations))        # All tasks have been submitted or enqueued        # Wait for them to complete        wait(futures)    # Convert observations to new tool messages to add to the state    new_observations = {        k: (task_names[k], args_for_tasks[k], observations[k])        for k in sorted(observations.keys() - originals)    }    tool_messages = [        FunctionMessage(            name=name,            content=str(obs),            additional_kwargs={"idx": k, "args": task_args},            tool_call_id=k,        )        for k, (name, task_args, obs) in new_observations.items()    ]    return tool_messages

创建计划和调度的组合函数：

import itertools@as_runnabledef plan_and_schedule(state):    messages = state["messages"]    tasks = planner.stream(messages)# Begin executing the planner immediately    try:        tasks = itertools.chain([next(tasks)], tasks)    except StopIteration:        # Handle the case where tasks is empty.        tasks = iter([])    scheduled_tasks = schedule_tasks.invoke(        {            "messages": messages,            "tasks": tasks,        }    )    return {"messages": scheduled_tasks}

测试执行示例：

tool_messages = plan_and_schedule.invoke({"messages":[HumanMessage(content=example_question)]})["messages"]# 输出示例:# [FunctionMessage(content="[{'url': '...', 'content': '...'}]", additional_kwargs={'idx': 1, 'args': {'query': 'current temperature in San Francisco'}}, response_metadata={}, name='tavily_search_results_json', tool_call_id=1),#  FunctionMessage(content='ValueError(...)', additional_kwargs={'idx': 2, 'args': {'problem': 'x^3', 'context': ['$1']}}, response_metadata={}, name='math', tool_call_id=2),#  FunctionMessage(content='join', additional_kwargs={'idx': 3, 'args': ()}, response_metadata={}, name='join', tool_call_id=3)]

系统的调度逻辑包括：

持续监控任务依赖关系的满足情况，使用ThreadPoolExecutor实现真正的并行处理，统一收集和管理任务执行结果。

在我们编写的上述温度计算示例中，系统实际执行了以下操作：搜索任务返回了旧金山的天气信息，数学计算任务由于缺乏具体的温度数值而失败， join操作识别到执行失败的情况

3.4 连接器与重规划机制

连接器使用结构化输出来决定下一步行动。首先定义必要的数据模型：

from langchain_core.messages import AIMessagefrom pydantic import BaseModel, Fieldfrom typing import Unionclass FinalResponse(BaseModel):"""最终响应"""    response: strclass Replan(BaseModel):"""重新规划"""    feedback:str= Field(        description="Analysis of the previous attempts and recommendations on what needs to be fixed.")classJoinOutputs(BaseModel):"""Decide whether to replan or whether you can return the final response."""    thought:str= Field(        description="The chain of thought reasoning for the selected action")    action: Union[FinalResponse, Replan]

创建连接器的核心组件：

joiner_prompt = hub.pull("wfh/llm-compiler-joiner").partial(    examples="")# You can optionally add examplesllm = ChatOpenAI(model="gpt-4o")runnable = joiner_prompt | llm.with_structured_output(    JoinOutputs, method="function_calling")

实现连接器的辅助函数：

def_parse_joiner_output(decision: JoinOutputs)-> List[BaseMessage]:    response =[AIMessage(content=f"Thought: {decision.thought}")]ifisinstance(decision.action, Replan):return{"messages": response            +[                SystemMessage(                    content=f"Context from last attempt: {decision.action.feedback}")]}else:return{"messages": response +[AIMessage(content=decision.action.response)]}def select_recent_messages(state)->dict:    messages = state["messages"]    selected =[]for msg in messages[::-1]:        selected.append(msg)ifisinstance(msg, HumanMessage):breakreturn{"messages": selected[::-1]}# 组合连接器joiner = select_recent_messages | runnable | _parse_joiner_output

测试连接器功能：

input_messages =[HumanMessage(content=example_question)]+ tool_messagesresult = joiner.invoke({"messages": input_messages})# 输出示例:# {'messages': [AIMessage(content='Thought: Since the temperature in San Francisco was not provided, I cannot calculate its value raised to the 3rd power. The search result did not include specific temperature information, and the subsequent action to calculate the power raised the error due to lack of numerical input.', additional_kwargs={}, response_metadata={}),#   SystemMessage(content="Context from last attempt: To answer the user's question, we need the current temperature in San Francisco. Please include a step to find the current temperature in San Francisco and then calculate its value raised to the 3rd power.", additional_kwargs={}, response_metadata={})]}

当初次执行失败时，连接器会分析失败原因并触发重规划：

由于搜索结果没有提供具体的温度数值，无法进行数学计算。

需要找到旧金山的具体当前温度，然后计算其三次方。

4. 完整系统集成

使用LangGraph框架，我们将各个组件整合为一个状态图。首先导入必要的模块：

from langgraph.graph import END, StateGraph, STARTfrom langgraph.graph.message import add_messagesfrom typing import Annotatedclass State(TypedDict):    messages: Annotated[list, add_messages]

构建完整的系统图：

graph_builder = StateGraph(State)# 1. Define vertices# We defined plan_and_schedule above already# Assign each node to a state variable to updategraph_builder.add_node("plan_and_schedule", plan_and_schedule)graph_builder.add_node("join", joiner)## Define edgesgraph_builder.add_edge("plan_and_schedule", "join")### This condition determines looping logicdef should_continue(state):    messages = state["messages"]    if isinstance(messages[-1], AIMessage):        return END    return "plan_and_schedule"graph_builder.add_conditional_edges(    "join",    # Next, we pass in the function that will determine which node is called next.    should_continue,)graph_builder.add_edge(START, "plan_and_schedule")# 编译完整的执行链chain = graph_builder.compile()

系统的循环逻辑通过条件边来实现，确保在需要时能够自动触发重规划。当连接器返回SystemMessage时，系统会重新进入规划和调度阶段；当返回AIMessage时，系统结束执行。

5. 实验验证

5.1 简单查询处理

查询："What's the GDP of New York?"

for step in chain.stream({"messages":[HumanMessage(content="What's the GDP of New York?")]}):print(step)print("---")# 输出：# {'plan_and_schedule': {'messages': [FunctionMessage(content="[{'url': 'https://www.investopedia.com/articles/investing/011516/new-yorks-economy-6-industries-driving-gdp-growth.asp', 'content': 'The manufacturing sector is a leader in railroad rolling stock, as many of the earliest railroads were financed or founded in New York; garments, as New York City is the fashion capital of the U.S.; elevator parts; glass; and many other products.\\n Educational Services\\nThough not typically thought of as a leading industry, the educational sector in New York nonetheless has a substantial impact on the state and its residents, and in attracting new talent that eventually enters the New York business scene. New York has seen a large uptick in college attendees, both young and old, over the 21st century, and an increasing number of new employees in other New York sectors were educated in the state. New York City is the leading job hub for banking, finance, and communication in the U.S. New York is also a major manufacturing center and shipping port, and it has a thriving technological sector.\\n The state of New York has the third-largest economy in the United States with a gross domestic product (GDP) of $1.7 trillion, trailing only Texas and California.'}]", additional_kwargs={'idx': 1, 'args': {'query': 'GDP of New York'}}, response_metadata={}, name='tavily_search_results_json', tool_call_id=1)]}}# ---# {'join': {'messages': [AIMessage(content='Thought: The search result provides the specific information requested. It states that the state of New York has the third-largest economy in the United States with a GDP of $1.7 trillion.', additional_kwargs={}, response_metadata={}, id='63af07a6-f931-43e9-8fdc-4f2b8c7b7663'), AIMessage(content='The GDP of New York is $1.7 trillion.', additional_kwargs={}, response_metadata={}, id='7cfc50e6-e041-4985-a5f4-ebf2e097826e')]}}# ---# Final answerprint(step["join"]["messages"][-1].content)# The GDP of New York is $1.7 trillion.

执行过程：

系统执行搜索任务获取纽约GDP信息
搜索结果显示纽约州GDP为1.7万亿美元
连接器直接提供最终答案

结果："The GDP of New York is $1.7 trillion."

这个例子展示了系统处理单步查询的高效性。

5.2 多条查询处理

查询："What's the oldest parrot alive, and how much longer is that than the average?"

steps = chain.stream({"messages":[            HumanMessage(                content="What's the oldest parrot alive, and how much longer is that than the average?")]},{"recursion_limit":100,},)for step in steps:print(step)print("---")# 输出：# {'plan_and_schedule': {'messages': [FunctionMessage(content='[{\'url\': \'https://en.wikipedia.org/wiki/Cookie_(cockatoo)\', \'content\': \'He was one of the longest-lived birds on record[4] and was recognised by the Guinness World Records as the oldest living parrot in the world.[5]\\nThe next-oldest pink cockatoo to be found in a zoological setting was a 31-year-old female bird located at Paradise Wildlife Sanctuary, England.[3] Information published by the World Parrot Trust states longevity for Cookie\\\'s species in captivity is on average 40–60 years.[6]\\nLife[edit]\\nCookie was Brookfield Zoo\\\'s oldest resident and the last surviving member of the animal collection from the time of the zoo\\\'s opening in 1934, having arrived from Taronga Zoo of Sydney, New South Wales, Australia, in the same year and judged to be one year old at the time.[7]\\nIn the 1950s an attempt was made to introduce Cookie to a female pink cockatoo, but Cookie rejected her as "she was not nice to him".[8]\\n In 2007, Cookie was diagnosed with, and placed on medication and nutritional supplements for, osteoarthritis and osteoporosis\\xa0– medical conditions which occur commonly in aging animals and humans alike,[7] although it is believed that the latter may also have been brought on as a result of being fed a seed-only diet for the first 40 years of his life, in the years before the dietary requirements of his species were fully understood.[9]\\nCookie was "retired" from exhibition at the zoo in 2009 (following a few months of weekend-only appearances) in order to preserve his health, after it was noticed by staff that his appetite, demeanor and stress levels improved markedly when not on public display. age.[11] A memorial at the zoo was unveiled in September 2017.[12]\\nIn 2020, Cookie became the subject of a poetry collection by Barbara Gregorich entitled Cookie the Cockatoo: Everything Changes.[13]\\nSee also[edit]\\nReferences[edit]\\nExternal links[edit] He was believed to be the oldest member of his species alive in captivity, at the age of 82 in June 2015,[1][2] having significantly exceeded the average lifespan for his kind.[3] He was moved to a permanent residence in the keepers\\\' office of the zoo\\\'s Perching Bird House, although he made occasional appearances for special events, such as his birthday celebration, which was held each June.[3]\'}]', additional_kwargs={'idx': 1, 'args': {'query': 'oldest parrot alive'}}, response_metadata={}, name='tavily_search_results_json', tool_call_id=1), FunctionMessage(content="[{'url': 'https://www.birdzilla.com/learn/how-long-do-parrots-live/', 'content': 'In captivity, they can easily live to be ten or even 18 years of age. In general, most wild parrot species live only half the numbers of years they would live in captivity. For example, adopted African Gray Parrots might live to be 60, whereas wild birds have an average lifespan of 30 or 40 at the very most.'}]", additional_kwargs={'idx': 2, 'args': {'query': 'average lifespan of a parrot'}}, response_metadata={}, name='tavily_search_results_json', tool_call_id=2), FunctionMessage(content='join', additional_kwargs={'idx': 3, 'args': ()}, response_metadata={}, name='join', tool_call_id=3)]}}# ---# {'join': {'messages': [AIMessage(content="Thought: The information from Wikipedia about Cookie, the cockatoo, indicates that he was recognized as the oldest living parrot, reaching the age of 82. This significantly exceeds the average lifespan for his species, which is noted to be 40-60 years in captivity. The information from Birdzilla provides a more general perspective on parrot lifespans, indicating that, in captivity, parrots can easily live to be ten or even 18 years of age, with some species like the African Gray Parrot potentially living up to 60 years. However, it does not provide a specific average lifespan for all parrot species, making it challenging to provide a precise comparison for Cookie's age beyond his species' average lifespan.", additional_kwargs={}, response_metadata={}, id='f00a464e-c273-42b9-8d1b-edd27bde8687'), AIMessage(content="Cookie the cockatoo was recognized as the oldest living parrot, reaching the age of 82, which is significantly beyond the average lifespan for his species, noted to be between 40-60 years in captivity. While general information for parrots suggests varying lifespans with some capable of living up to 60 years in captivity, Cookie's age far exceeded these averages, highlighting his exceptional longevity.", additional_kwargs={}, response_metadata={}, id='dc62a826-5528-446e-8797-6854abdeb94c')]}}# ---# Final answerprint(step["join"]["messages"][-1].content)# Cookie the cockatoo was recognized as the oldest living parrot, reaching the age of 82, which is significantly beyond the average lifespan for his species, noted to be between 40-60 years in captivity. While general information for parrots suggests varying lifespans with some capable of living up to 60 years in captivity, Cookie's age far exceeded these averages, highlighting his exceptional longevity.

执行过程：

并行执行两个搜索任务：
- 搜索最老的鹦鹉
- 搜索鹦鹉平均寿命
获得Cookie鹦鹉（82岁）和平均寿命（40-60年）的信息
连接器综合分析两个结果提供完整答案

结果：系统成功识别出Cookie鹦鹉的异常长寿，并与同类平均寿命进行了比较分析。

5.3 多步数学计算

查询："What's ((3\*(4+5)/0.5)+3245) + 8? What's 32/4.23? What's the sum of those two values?"

执行过程：

并行执行两个数学计算任务：
- 第一个表达式：结果为3307.0
- 第二个表达式：结果为7.565011820330969
系统自动识别需要将两个结果相加
连接器提供包含所有计算步骤的完整答案

结果："The sum of those two values is 3307.0 + 7.57 = approximately 3314.57."

5.4 复杂重规划示例

查询："Find the current temperature in Tokyo, then, respond with a flashcard summarizing this information"

执行过程：

搜索东京当前温度：84°F，部分晴朗
连接器识别到需要创建闪卡格式的总结
生成结构化的闪卡响应

最终输出：

**Flashcard: Current Temperature in Tokyo**- **Temperature:** 84 °F- **Weather Conditions:** Partly sunny*Note: This information is based on the latest available data and may change.*