fix: main.py — Создайть просто AI агент на Python с применением langchain

main.py

@@ -1,47 +1,74 @@
 import os
 import asyncio
-from langchain_openai import ChatOpenAI
+from typing import Any
-from langchain.tools import tool
-from langchain.agents import create_agent
-from langchain_core.messages import HumanMessage
-from deepagents import create_deep_agent
-from deepagents.backends import CompositeBackend, LocalShellBackend, FilesystemBackend
 
-# ---------- LLM ----------
+from langchain_openai import ChatOpenAI
-# Use OpenRouter – cloud API, no local GPU required
+from langchain_core.messages import HumanMessage
+from langchain.tools import tool
+from deepagents import create_deep_agent
+from deepagents.backends import FilesystemBackend, LocalShellBackend, CompositeBackend
+
+# LLM configuration according to the assignment specification
 llm = ChatOpenAI(
-    model="openai/gpt-oss-20b:free",
+    model="your-model-name",  # replace with the actual model name in LM Studio
-    base_url="https://openrouter.ai/api/v1",
+    base_url="http://localhost:1234/v1",
-    api_key=os.getenv("OPENAI_API_KEY"),
+    api_key="fake",  # OpenAI SDK requires a non-empty key
     temperature=0.7,
 )
 
-# ---------- Backend ----------
+# Backend for file operations and shell commands (required by deepagents)
-backend = CompositeBackend([
+backend = CompositeBackend(
+    [
         LocalShellBackend(workspace_dir="./workspace"),
         FilesystemBackend(),
-])
+    ]
+)
 
-# ---------- Tool with sub‑agent ----------
 @tool
 def get_price(product: str, city: str) -> str:
-    """Return a realistic price table for a product in a city.
-    The tool internally creates a sub‑agent that generates the table.
     """
-    # Sub‑agent that simply produces a price table
+    Retrieve a realistic price for the given product in the specified city.
-    sub_agent = create_agent(
+    The function creates a sub-agent that returns a markdown table row.
+    """
+    # System prompt for the sub-agent - it must output a table with columns
+    # Product, Price (руб.), Store.
+    sub_system_prompt = (
+        "You are a price generator. Provide a markdown table with columns "
+        "'Продукт', 'Цена (руб.)', 'Магазин' for the given product and city. "
+        "Give a realistic price and a plausible store name."
+    )
+
+    # Create the sub-agent (no additional tools needed)
+    sub_agent = create_deep_agent(
         model=llm,
         tools=[],
-        system_prompt=f"You are a price estimator for {city}. Provide a realistic price for {product} in a table format.",
+        backend=backend,
+        system_prompt=sub_system_prompt,
     )
-    prompt = (
+
-        f"Generate a table with columns Продукт, Цена (руб.), Магазин for product '{product}' in city '{city}'."
+    # Prepare the query for the sub-agent
+    query = f"Provide price information for {product} in {city}."
+
+    # Invoke the sub-agent synchronously
+    # DESIGN DECISION: Use asyncio.run to execute the sub-agent inside a
+    # synchronous tool. deepagents operates asynchronously, but the tool
+    # interface required by the main agent is synchronous.
+    # NECESSITY: The assignment defines the tool as a regular function.
+    # OPTIMALITY: This approach keeps the code simple and avoids mixing
+    # async/sync contexts incorrectly.
+    # ALTERNATIVES CONSIDERED: Making the tool async (deepagents supports
+    # async tools) would require changes to the main agent invocation pattern,
+    # which is unnecessary for this educational example.
+    result = asyncio.run(
+        sub_agent.ainvoke(
+            {"messages": [HumanMessage(content=query)]},
+            {"configurable": {"thread_id": f"price-{product}-{city}"}},
         )
-    result = sub_agent.invoke({"messages": [HumanMessage(content=prompt)]})
+    )
-    # The last message contains the table
+    # Extract the final content from the sub-agent's response
     return result["messages"][-1].content
 
-# ---------- Main agent ----------
+# Main shopping-list agent
 agent = create_deep_agent(
     model=llm,
     tools=[get_price],
@@ -49,27 +76,26 @@ agent = create_deep_agent(
     system_prompt="Ты помощник по планированию покупок.",
 )
 
-# ---------- Helper to pretty‑print messages ----------
+def format_message(message: Any) -> str:
+    """Convert a LangChain message to a readable string."""
+    if hasattr(message, "content") and message.content:
+        return message.content
+    if hasattr(message, "tool_calls") and message.tool_calls:
+        tc = message.tool_calls[0]
+        return f"{tc['name']}({tc['args']})"
+    return str(message)
 
-def format_message(msg):
+async def main() -> None:
-    if hasattr(msg, "content") and msg.content:
-        return msg.content
-    if hasattr(msg, "tool_calls") and msg.tool_calls:
-        call = msg.tool_calls[0]
-        return f"{call['name']}({call['args']})"
-    return ""
-
-# ---------- Main execution ----------
-async def main():
     user_query = "Помоги составить список покупок: молоко, хлеб, яблоки. Я нахожусь в Казани."
     result = await agent.ainvoke(
         {"messages": [HumanMessage(content=user_query)]},
-        {"configurable": {"thread_id": "session-1"}},
+        {"configurable": {"thread_id": "shopping-session-1"}},
     )
-    # Print all messages in order
+    # Output the whole chain of messages
-    for msg in result["messages"]:
+    for idx, msg in enumerate(result["messages"], start=1):
+        print(f"--- Message {idx} ---")
         print(format_message(msg))
-        print("---")
+        print()
 
 if __name__ == "__main__":
     asyncio.run(main())