langchain-ai

AI Agents Explained: How They Can Spend Your Money Or Email The Boss By Mistake Companies are rolling out AI agents that can book trips, buy things and send messages for you, but one bad instruction can spend your money or email your boss by mistake. AI agents are systems that use a language model plus memory, tools, and rules to complete tasks with less step-by-step human help. A plain LLM usually gives one response at a time, while an agent can make a plan, take action, check what happened, and try again. The upside is automation, but the risk is that bad instructions, weak guardrails, or risky tool access can turn a small error into a real-world mistake. Quick Summary - AI agents are systems that use a language model plus memory, tools, and rules to complete tasks with less step-by-step human help. - A plain LLM usually gives one response at a time, while an agent can make a plan, take action, check what happened, and try again. - The upside is automation, but the risk is that bad instructions, weak guardrails, or risky tool access can turn a small error into a real-world mistake. What AI Agents Actually Are Most people meet AI through a chatbot. You type a question, and it replies. That is useful, but it is only one layer of modern AI. AI agents add structure around the model so it can do more than answer once. In simple terms, an agent is a system built around a large language model, or LLM, that can keep working toward a goal across multiple steps, deciding what to do next, calling outside tools, reading the results, and continuing until it reaches a stopping point. That is the core difference. OpenAI said its Agents API pairs the model with a harness that manages context, uses tools and coordinates subagents, plus a sandbox where the agent can run code and work with files. That setup matters because it shows an agent is not just a model. It is a model plus the rules and systems around it. Think of the difference this way. A plain LLM is like a student who answers one exam question. An agent is like an intern with a checklist, a browser, a calendar, and access to company files. The intern may still make mistakes, but it can do much more than write one paragraph. That does not mean every AI feature needs an agent. Sometimes a normal prompt to a model is faster, cheaper, and safer. Agents are most helpful when the task has many steps, changing information, or outside systems to work with. AI Agents Vs LLMs A plain LLM works by predicting the next word based on the text it has seen. That lets it summarize, answer questions, write code, and translate language. But by itself, it does not truly act in the world. It only returns an output. Anthropic said people use the word "agent" in different ways, from fully autonomous systems to simpler systems that follow a fixed workflow, but the common idea is that the model directs a process instead of producing one isolated answer. That is a good way to separate hype from reality. A basic comparison helps. - A plain LLM works best for one-shot tasks. - An agent is best for multi-step tasks. - A plain LLM usually needs the full prompt every time. - An agent can use memory, tools, and state across steps. - A plain LLM stops after giving one answer. - An agent can continue until a goal is met or a rule stops it. Here is an example. If you ask a plain LLM, "Find the three cheapest flights to Chicago next Friday," it may guess based on its training data or tell you to search for them yourself. An agent can search travel sites, compare live prices, ask whether bags matter, and return a short list. That is why the difference is not just model quality. It is system design, and connecting the model to memory, tools, and rules is the big shift. The Core Parts That Make Agents Autonomous To understand why agents feel different, it helps to break them into parts. Most working agent systems reuse the same building blocks. The first part is the model. This is the LLM that reads the user's request, thinks through the text, and chooses the next action. Without the model, there is no flexible decision-making. The second part is memory. Memory can mean short-term context, like the messages in the current session, or longer-term stored facts, like your preferences or past tasks. Without memory, the agent starts from zero each time. The third part is tools. A tool is any outside action the model can call. That could be web search, code execution, a calculator, a company database, email, or a payment system. Tools are what let an agent affect the world beyond text. The fourth part is state. State means the current record of what has happened so far. Anthropic's research on Managed Agents describes the session as an append-only log of everything that happened. That idea is important because agents need a reliable record to avoid getting lost mid-task. The fifth part is planning. Some agents plan explicitly by listing sub-tasks. Others plan implicitly by deciding one next step at a time. Either way, they need some method for breaking a goal into actions. The sixth part is guardrails. These are rules that limit what the agent can do. Guardrails might block dangerous tools, require approval before spending money, filter harmful requests, or stop a task after too many failed attempts. The seventh part is evaluation. Good agent systems do not just act. They check whether the action worked. That may mean testing code, reading an error message, or asking a second model to review the result. When people say agents are autonomous, they usually mean these parts work together with less human input. The system still depends on people for setup, limits, and oversight. But during the task, it can operate on its own for longer. If a chatbot is one turn at a time, an agent is a system that keeps state across turns and actions. Why Tools And Workflows Matter More Than Raw Model Size A lot of newcomers assume AI agents are just the newest and biggest models. That misses the point. In many cases, the jump in usefulness comes from the workflow around the model, not just the model alone. OpenAI said building agents works best when systems need to make decisions and handle messy, multi-step tasks that normal automation cannot handle well. That tells you where agents fit. They are not for every task, but they suit tasks with branching paths, unclear inputs, or changing information. A simple customer support bot may not need agent behavior. If the questions are predictable, a fixed workflow is often enough. But if a support system must look up orders, refund fees, check shipping status, and decide whether a case breaks company policy, agent design starts to make sense. This is also why many teams use a mix of patterns. - Workflow agents follow a known sequence with some model help - Tool-using agents choose from a set of outside actions - Multi-agent systems split a job across specialist agents - Human-in-the-loop agents pause when approval is needed OpenAI said its Agents API hosts the harness for builders while letting them choose where the agent runs, and is built to keep agents running reliably for days. Reliability matters because the hard part is not getting one good answer. It is getting many acceptable answers over time in messy real settings. LangChain said its software helps developers connect compatible parts and outside tools when building agents and LLM apps. That is another sign of what the market has learned: agent performance depends on how well the pieces connect, not just on the model benchmark score. Also Read: CrowdStrike Lets Firms Watch Every Move Claude agents Make A useful mental model is this. The model is the brain-like part. The tools are the hands. Memory is the notebook. Guardrails are the workplace rules. The workflow is the job design. A weak setup can waste a strong model. A solid setup can make a mid-range model much more useful. The Main Agent Architectures You Will Hear About Not all agents are built the same way. A few patterns show up again and again, and knowing them helps you decode product claims. The first is the single-agent loop. One model handles the whole task. It reads the request, picks a tool, reads the result, and continues until done. This is the simplest pattern and often the easiest place to start. The second is the planner and executor setup. One model or step creates a plan. Another carries it out. This can improve organization because the system separates "what should happen" from "do the next action." The third is the supervisor and subagent model. A top-level agent manages specialist subagents. One subagent may handle coding. Another may search internal files. Another may write a final summary. Anthropic said subagents can help manage context by giving different tasks their own working space and limits. The fourth is the skills-based model. Instead of expecting one agent to remember everything, the system can load task-specific instructions and resources only when needed. Anthropic wrote about "Agent Skills" as organized folders of instructions, scripts, and resources that agents can discover and load dynamically. That approach matters because it reduces clutter and helps the agent stay focused. The best agent architecture is usually the simplest one that can finish the task safely. The fifth is the multi-agent system. Several agents interact, cooperate, or compete. This can boost scale and specialization, but it adds new failure points. One agent can misunderstand another. Plans can drift. Costs can rise fast. You may also hear about MCP servers, short for Model Context Protocol servers. In plain English, that means a standard way for models to connect to tools and data sources. Standard connections make it easier to plug the same model into different systems without custom work each time. In practice, most good products use the lightest structure that gives acceptable results. Where AI Agents Work Best In The Real World The most useful question is not "Are agents impressive?" It is "What jobs do they do well?" The answer is usually jobs with many small decisions, lots of reading, or repeated tool use. OpenAI's own staff data showed its heaviest users generating more than 60 hours of Codex agent turns per day by June 2026, with research use growing fastest, which lines up with where agents already make sense in practice. Common use cases include these. - Research assistants that search, compare, and summarize sources - Coding assistants that write, test, and fix software - Customer support systems that read account data and take approved actions - Sales assistants that draft follow-ups and update customer records - Personal productivity tools that manage calendars, reminders, and email - Data agents that run queries, make charts, and write summaries There are also more advanced areas. Google DeepMind said SIMA 2 is aimed at virtual 3D worlds where an agent can play, reason, and learn with a user. That points to a broader future where agents move beyond text and into software, games, and robots. A good rule is that agents work best where success can be checked. If the agent writes code, tests can confirm it. If it books a meeting, a calendar event proves it worked. If it summarizes a legal issue with no easy way to verify accuracy, risk is higher. That is why agents fit operations work better than pure judgment work. They can save time on structured tasks and are weaker when the task needs deep values, context, or irreversible decisions. AI Agents Main Risks And Attack Surfaces The risks of AI agents are not just the normal risks of chatbots. Once a system can act, mistakes can spread farther and faster. The first risk is tool misuse. If an agent can send emails, move files, run code, or spend money, a bad choice is no longer just bad text. It becomes an action. That is why access control matters so much. The second risk is hallucination with momentum. A plain model may invent a fact in one answer. An agent may build three more steps on top of that bad fact. The longer the chain, the more damage a small mistake can cause. The third risk is prompt injection. That means outside text tricks the agent into ignoring its real instructions. A web page, document, or email can contain hostile text that says, in effect, "Forget your old rules and do this instead." The fourth risk is goal drift. An agent starts with one aim but slowly shifts course as it takes actions and reacts to noisy results. Without strong checks, it may complete the wrong task well. The fifth risk is hidden failure. Agent systems can look busy and confident while failing quietly. They may loop, use the wrong tool, or stop early without telling anyone. Google DeepMind published its plan for securing internal systems against AI, which treats a highly capable agent that may not share its goals like a potential insider threat. That is a reminder that security must be built into design. A newer research concern is that stronger agents do not always mean safer groups of agents. A paper on arXiv found that increasing intelligence in AI-agent populations can worsen some collective behaviors under certain conditions. That matters as firms race toward teams of agents. More autonomy can create more value, but it also creates more ways to fail. The practical answer is layered control: limit tool access, require approval for sensitive actions, keep strong logs, test agents on bad inputs not just ideal ones, and never assume fluent language means sound judgment. Who Actually Needs AI Agents Not every person or company needs AI agents. In many cases, a simple chatbot or ordinary software automation is enough. Students may benefit from agents that organize research sources, turn notes into study plans, or draft code and test it, but they should be careful with accuracy. Freelancers and small businesses may get the most value from narrow agents for invoice follow-up, customer email sorting, lead research, and meeting preparation, which are repetitive tasks and easy to check. Larger companies often care about agents for internal work, systems that can search documents, open support tickets, check rules, and hand off hard cases to humans. Here the key issue is reliability and control rather than novelty. Developers are a special case because coding agents can produce clear gains fast, because code can be run, tested, and reviewed, making it one of the best early uses of agent design. If you are deciding whether to use an agent, ask four questions. - Does the task require many steps? - Does it need outside tools or live data? - Can the result be checked? - Is the cost of a wrong action low enough to manage? If the answer is no to most of those, you may not need an agent at all. Conclusion Watch next for enterprise deployments that enforce strict tool access controls, regulatory guidance on agent safety, advances in multi-agent coordination research, and product moves that make agent logs and approvals easier to audit. Read Next: BlueFlag Security Makes Humans Approve Bot Code Actions --- Originally published on Fathom News.

im telling you, you gotta try content studio... luckily for you, its open source langchain-ai/design-agent

Deep Agents: The batteries-included agent harness (31k stars) What it does All text below is quoted directly from the project README. >The batteries-included agent harness. Features include: - Sub-agents: delegate tasks to agents with isolated context windows - Filesystem: read, write, edit, or search over pluggable local, sandboxed, or remote backends - Context management: summarize long threads and offload tool outputs to disk - Shell access: run commands in your sandbox of choice - Persistent memory: pluggable state and store backends for cross-session recall - Human-in-the-loop: approve, edit, or reject tool calls before they run - Skills: reusable behaviors the agent can load on demand - Tools: bring your own functions or any MCP server >uv add deepagents Repository langchain-ai/deepagents Repository stats |Metric|Value| |:-|:-| |Stars|30,780| |Forks|4.3k| |Last release|deepagents==0.7.32 (2026-10-23)| |Languages|Python 98.9%, Other 1.1%| |Contributors|183| |AI contributor accounts (Claude / Codex / Cursor / Copilot)|@claude (21 commits), @cursoragent (14 commits), @Copilot (10 commits), @Copilot (7 commits)| |AI co-authored commits|Claude: 20, Cursor: 14, Copilot: 19| Main contributor |Field|Value| |:-|:-| |Name|Mason Daugherty| |GitHub|@mdrxy| |Commits to this repo|2,617 (top contributor)| |Bio|Engineering @langchain-ai| |Company / Location|Cambridge, MA| |Followers|728| ────────────────────────────── 📌 If you want to browse more repos like this, we've organized them by category and rankings here: bestgithubrepositories.com 🗂️ We're also archiving repos where possible, so useful projects don't disappear when they're removed from GitHub.

LlamaIndex Workflows vs LangGraph: Event-Driven Architecture and Async State Overhead Showdown LlamaIndex Workflows and LangGraph represent the two dominant paradigms for orchestrating complex agentic swarms: pure event-driven asynchronous message passing versus stateful directed acyclic graph (DAG) state machines. In production multi-agent systems, selecting between these two architectures determines your system's p99 latency profile, state recovery ergonomics, and memory utilization under high concurrency. By benchmarking both frameworks across 500 multi-branch execution tasks at SaaSNext, we discovered that while LangGraph offers superior relational checkpointer persistence, LlamaIndex Workflows cuts dispatch latency by 58% on complex branching paths. - Core Mechanism: Event-driven typed queue dispatching (LlamaIndex) versus compiled Pregel graph state machines (LangGraph). - Hardware & Runtime: Python 3.12, LlamaIndex Core v0.12+, LangGraph v0.2.35+, PostgreSQL 16, and Asyncio. - Production Value: LlamaIndex cuts async branching overhead by 58% while LangGraph provides deterministic time-travel state recovery. Explore production orchestration patterns in the Daily AI World workflows directory to see how modern engineering teams structure resilient autonomous pipelines. +--------------------------------------------------------------------------+ | AGENT ORCHESTRATION ARCHITECTURAL SHOWDOWN | +--------------------------------------------------------------------------+ | [LlamaIndex Workflows: Event-Driven] [LangGraph: Pregel State Graph]| | Steps emit typed Event objects. Nodes read/write global state. | | Dynamic publish-subscribe pattern. Fixed compiled edges & routes. | | Arbitrary async many-to-many fan-out. Deterministic superstep loops. | | Low memory footprint (sub-2ms dispatch). Heavy checkpointer snapshots. | +--------------------------------------------------------------------------+ Why Orchestration Mechanics Dictate Agent Reliability Under High Concurrency At SaaSNext, our internal code security auditor coordinates 25 specialized verification agents across pull requests. When we built our v1 implementation on LangGraph, our team praised its strict checkpointing model: every node transition is serialized into PostgreSQL, allowing human auditors to inspect agent state and resume interrupted execution with mathematical predictability. However, as our test fleet expanded to hundreds of concurrent pull requests, LangGraph's synchronous graph compilation and state persistence began exacting a steep tax. Every superstep in LangGraph requires serializing the entire application state dictionary, committing database writes, and evaluating conditional edge routers. On complex queries requiring recursive exploration, this snapshotting overhead inflated p99 execution latency past 3,800ms. When we rebuilt the pipeline using LlamaIndex Workflows, the operational dynamics shifted completely. LlamaIndex eliminates the central graph canvas. Instead, each step is an independent asynchronous consumer listening for specific Event subclasses. When an agent step emits a CodeAuditCompletedEvent, the downstream synthesis step activates immediately without writing snapshot blobs to disk. In our benchmarks across high-throughput worker pools, this event-driven architecture reduced step dispatch overhead from 142ms down to 48ms, while keeping CPU consumption low and eliminating thread blocking across parallel branch loops. Side-by-Side Architectural Code Comparison To understand the core developer ergonomics, consider how each framework models dynamic branching and parallel context aggregation. # llamaindex_workflow_sample.py: Event-Driven Routing from llama_index.core.workflow import Workflow, StartEvent, StopEvent, step, Context, Event class SecurityAlertEvent(Event): severity: str finding: str class SecurityAuditWorkflow(Workflow): @step async def triage_code(self, ctx: Context, ev: StartEvent) -> SecurityAlertEvent: code_diff = ev.get("diff") # Direct event emission without updating global graph dictionaries return SecurityAlertEvent(severity="high", finding="SQL injection detected") @step async def dispatch_alert(self, ctx: Context, ev: SecurityAlertEvent) -> StopEvent: return StopEvent(result=f"Dispatched P1 alert: {ev.finding}") # langgraph_state_sample.py: Stateful Pregel Graph from typing import TypedDict, Annotated from langgraph.graph import StateGraph, START, END import operator class AuditState(TypedDict): diff: str findings: Annotated[list[str], operator.add] severity: str def triage_code_node(state: AuditState) -> dict: return {"findings": ["SQL injection detected"], "severity": "high"} def route_decision(state: AuditState) -> str: return "dispatch_alert" if state["severity"] == "high" else "log_info" builder = StateGraph(AuditState) builder.add_node("triage", triage_code_node) builder.add_conditional_edges("triage", route_decision) builder.add_edge(START, "triage") graph = builder.compile() > "In production testing at SaaSNext across 15,000 synthetic multi-branch reasoning tasks, LlamaIndex Workflows reduced mean step dispatch duration from 142ms to 48ms while decreasing memory footprint by 46%." Empirical Benchmark: LlamaIndex Workflows vs LangGraph To quantify execution throughput, memory consumption, and state persistence overhead, we benchmarked both frameworks across 500 concurrent multi-agent executions. | Benchmark Dimension | LangGraph 0.2 (Postgres Checkpointer) | LangGraph (In-Memory Checkpointer) | LlamaIndex Workflows 0.12 | Delta / Engineering Gain | |---|---|---|---|---| | P50 Step Latency | 142 ms | 58 ms | 24 ms | 58.6% faster step execution | | P99 Superstep Overhead | 680 ms | 190 ms | 62 ms | 67.3% lower tail latency | | RAM per 100 Workflows | 4.6 GB | 2.8 GB | 1.4 GB | 50.0% lower memory usage | | State Snapshot Time | 48 ms (DB write) | 6 ms (Dict copy) | 0 ms (Event queue) | Zero disk persistence tax | | Crash Recovery Precision | 100% (Exact step replay) | 0% (State lost on crash) | 88% (Event log replay) | LangGraph wins in durable recovery | | Arbitrary Branching Overhead | High (Requires edge matrix) | Medium | Sub-5ms (Typed event matching) | LlamaIndex wins in dynamic swarms | The benchmark highlights a fundamental architectural trade-off: LangGraph is built for durable, audit-heavy enterprise workflows where time-travel debugging and human-in-the-loop approvals justify checkpointer overhead. LlamaIndex Workflows is engineered for high-throughput, low-latency agent reasoning swarms where dynamic branching speed is paramount. > 💡 Related Engineering Blueprint: Building stateful interrupt loops with durable checkpointers? Inspect our guide on LangGraph Dynamic Interrupts with PostgreSQL: Sub-18ms Resumes to master human-in-the-loop state storage. Common Production Failure Modes: Framework-Specific Hardening When scaling these frameworks across production Kubernetes clusters, engineers encounter distinct failure modes: 1. LangGraph State Bloat: Accumulating large document embeddings directly inside the TypedDict state causes PostgreSQL checkpointer tables to balloon, degrading query times. Always store large payloads in external object stores (like S3) and pass only lightweight URI references in state. 2. LlamaIndex Orphaned Event Starvation: When a step fails to emit an event matching downstream listeners, the workflow hangs until timeout. Enforce global error interceptors configured to emit structured fallback events upon any uncaught exception. 3. LangGraph Checkpoint Deadlocks Under Concurrency: When multiple parallel branches attempt to checkpoint against the same thread ID simultaneously, database lock contention spikes. Use partitioned checkpointers or unique branch thread sub-identifiers. 4. LlamaIndex Memory Leak on Recursive Event Loops: Steps that recursively emit events without decrementing step ceilings cause process memory to expand infinitely. Always set ctx.set("step_count", count + 1) and enforce a strict ceiling. Architectural Verdict: When to Choose LlamaIndex vs LangGraph Choose LangGraph if your application requires strict regulatory compliance, reversible time-travel debugging, and long-running human-in-the-loop approval workflows that span days. Its Pregel state machine model is unmatched for deterministic auditability. Choose LlamaIndex Workflows if you are building autonomous research swarms, fast query decomposition pipelines, or high-throughput agent routers where sub-50ms dispatch latency and low memory consumption are essential. 📚 Authoritative Primary Sources & Research Citations - 🔗 Official Implementation: LlamaIndex Core Workflows Documentation — Technical specification of the event-driven Workflow and Context engine. - 🔗 GitHub Repository: LangGraph Open-Source Repository — Production codebase for Pregel-based multi-agent graphs. - 🔗 Research Paper: arXiv:2308.08155 — Communicative Agents for Software Development — Peer-reviewed evaluation of multi-agent state coordination paradigms. - 🔗 State Machine Standards: Pregel Distributed Graph Processing Framework — Architectural foundation of Pregel superstep execution models. 🚀 Recommended Next Architecture in This Stack Continue optimizing your autonomous multi-agent stack with our companion guides: - ⚡ Next Logical Implementation: Build an Autonomous LlamaIndex Event-Driven Workflow: Sub-60ms Async Agent Routing — Implement the complete event-driven workflow in production. - 🛠️ Directory Hub: Explore hundreds of production-ready architectures in the Daily AI World Workflows Directory and Model Context Protocol Hub. By <a href="x.com" rel="author">Deepak Bagada</a>, Founder & Editor-in-Chief at Daily AI World. --- > 🌐 Original Source Attribution: > This comprehensive engineering breakdown was originally published on Daily AI World by Deepak Bagada. > > Explore the full Daily AI World Workflow Directory for enterprise-grade autonomous swarms, MCP servers, and LLM orchestration blueprints.

agent 跑长任务，上下文就爆，记忆还跨不了会话？ deepagents 是 agent 骨架：子 agent 分工、上下文压缩、持久记忆、人工审批全配齐。 适合快速搭个能干长活的 agent 的人，不想从零拼 harness。 先用它搭什么，长任务助手还是多 agent 分工？ #Agent #LangChain @grok langchain-ai/deepagents

最近在Ai辅助游戏的UIUX设计上遇到的瓶颈 在查阅资料的时候发现了 @LangChain 发了他们的文章 langchain.com 同时也开源了代码：langchain-ai/design-agent 可以粗浅分成两类：一方面agent该如何设计，二是如何让agent具有审美 我们主要说：如何让agent具有审美（因为他们文里其实把「agent 该如何设计」拆得更细一点 关于这一点，我过去一直在想，我只要把足够多的参考浓缩成某种skill是不是就可以了，但其实不太一样 Longchain是这么做的： 1. Taste = context，不是更强模型 alone 同 prompt：本地 coding agent + brand skill 仍 logo lockup/对齐/主次色错；Content Studio 用原则 + 反 AI slop 护栏 + 反馈理由 填 brief 没写死的缝。 比如说「no sharp edges」早期理解成圆角硬边；后来 agent 自己画尾巴根检查点，逐帧验飘带粘在鸟尾上，可测的用门禁，主观的把 reasoning 写进 skill。 2. Bitter Lesson 打在 harness 上 v1：115 个可复用 UI 组件 + 大量「何时用」规则 → 品牌稳但版式/动画重复。Opus 5.5 来了之后删大部分硬规则，只留原则和高层指导，多样性和创意决策回来了。 补偿模型弱点的规则会过期；留下的是环境：工具、context、人怎么 steer。 3. 知识四层（包含我之前的想法） -Skills（~48 个、~1000 文件）：按任务不是按主题；media-production 是路由表；描述写「何时用/何时不用」；彼此组合不重复。 -Wiki：品牌/话术/产品/70 条参考片；skill 只link过去。 -Gates：可量化的确定性检查（如默认大小写）。 -Memory：快环（当轮写偏好，团队层压过个人层，AGENTS.md 限 200 行索引——曾膨胀到 500K tokens）；慢环（learn_from_job 最多 5 条带证据教训，周更进 skill/wiki）。 4. 多玩家 UX + 主 agent 当参谋长 小时级任务：子 agent 异步；主 agent start_task / check_tasks / cancel·resume / report_progress / schedule_wakeup；人消息插进下一轮模型调用前。线程里：计划+ETA、子任务状态、渲染进度、花费、公开前审批卡。一例：52 页 overnight reskin，主 agent ~1h、子 agent 合计 >6h，不堵对话。 5. Point, don’t prompt（我真的很喜欢这个观点） Slack 线性说不清空间反馈 → Paper 画布 + MCP；人边点边改，agent 读注释。云 sandbox 连不上桌面工具时，他们用无头 Linux worker 跑 Paper，工程脏但解决协作。 所以：不是「设计 agent vs 审美」二选一对等： 审美是内容，harness 是载体，多玩家 UX 是落地条件 博客自己的三句话也是：designer judgment → custom environment → right UX

LangGraph AsyncPostgresSaver: fixing 'psycopg.OperationalError: the connection is closed' in FastAPI Updated 2026-10-29. Symptom: your LangGraph app works with MemorySaver, but after you switch to AsyncPostgresSaver behind FastAPI, the first request that touches a checkpoint raises psycopg.OperationalError: the connection is closed. The cause is where the async with block ends, not your database. The fix is to open the saver (or a pool) in the FastAPI lifespan. Disclosure: I work on MemorySync (I'm Mohammed, the founder). I drafted this page with AI assistance and checked it against the source issue and the official docs listed under Sources on Oct 28, 2026. I read the code and docs; I didn't run this FastAPI app for this page. The question In langchain-ai/langgraph#1292, "Encountering OperationalError with Postgres Checkpointer in LangGraph" (Aug 9, 2024), the Postgres checkpointer failed with: psycopg.OperationalError: the connection is closed The graph was compiled inside a function like this: async with AsyncPostgresSaver.from_conn_string(os.environ.get("POSTGRES_CONN_STRING")) as checkpointer: return workflow.compile( checkpointer=checkpointer, interrupt_before=[AgentRole.USER_INPUT], ) A later commenter asked the follow-up most FastAPI users have: how to compile the graph once in the lifespan and reuse it for every request, instead of compiling per request. Status (checked Oct 28, 2026 via the GitHub API): closed Aug 9, 2024, after the reply explaining the cause below. The FastAPI lifespan follow-up (Sep 2024, bumped Mar 2025) has no answer in the thread. Why it happens from_conn_string is an async context manager. The connection is open only inside the async with block. Returning the compiled graph from inside the block exits it, which closes the connection, but the graph still holds the checkpointer. The first request that reads or writes a checkpoint then hits psycopg's closed connection. As the reply on #1292 put it: when the function returns, "it is already out of the with scope, at which point the database connection has already been closed." Fix 1: keep the block open for the app's lifetime Enter the context manager in the lifespan and yield inside it, so it closes only on shutdown: from contextlib import asynccontextmanager from fastapi import FastAPI from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver @asynccontextmanager async def lifespan(app: FastAPI): async with AsyncPostgresSaver.from_conn_string(DB_URI) as checkpointer: await checkpointer.setup() # first run only: creates the tables app.state.graph = builder.compile(checkpointer=checkpointer) yield app = FastAPI(lifespan=lifespan) Fix 2: use a connection pool A single connection serves one request at a time. AsyncPostgresSaver also accepts a psycopg AsyncConnectionPool (its connection type in the source is AsyncConnection | AsyncConnectionPool). The package README says manually created connections need autocommit=True and row_factory=dict_row: from psycopg.rows import dict_row from psycopg_pool import AsyncConnectionPool @asynccontextmanager async def lifespan(app: FastAPI): async with AsyncConnectionPool( DB_URI, kwargs={"autocommit": True, "row_factory": dict_row}, ) as pool: checkpointer = AsyncPostgresSaver(pool) await checkpointer.setup() app.state.graph = builder.compile(checkpointer=checkpointer) yield The source raises an error if you combine a pool with pipeline; pipelines are for a single connection only. Example: lifespan pool plus a request handler This puts Fix 2 together with a handler. The saver and pool calls follow the langgraph-checkpoint-postgres README (autocommit=True, row_factory=dict_row) and AsyncPostgresSaver in langgraph/checkpoint/postgres/aio.py. builder is your StateGraph. I didn't run this app. from contextlib import asynccontextmanager from fastapi import FastAPI, Request from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver from psycopg.rows import dict_row from psycopg_pool import AsyncConnectionPool DB_URI = "postgresql://user:pass@localhost:5432/app" @asynccontextmanager async def lifespan(app: FastAPI): async with AsyncConnectionPool( DB_URI, open=False, kwargs={"autocommit": True, "row_factory": dict_row}, ) as pool: # opened here, closed only on shutdown checkpointer = AsyncPostgresSaver(pool) await checkpointer.setup() app.state.graph = builder.compile(checkpointer=checkpointer) yield app = FastAPI(lifespan=lifespan) @app.post("/chat/{thread_id}") async def chat(thread_id: str, body: dict, request: Request): graph = request.app.state.graph config = {"configurable": {"thread_id": thread_id}} return await graph.ainvoke({"messages": [("user", body["message"])]}, config) open=False with async with lets the context manager open the pool, which avoids psycopg_pool's warning about opening a pool in the constructor. Checklist 1. No return of a compiled graph from inside an async with ... as checkpointer block. 2. Compile once in the lifespan, read app.state.graph in handlers. 3. Call setup() the first time against a new database. 4. Manual connections or pools: autocommit=True and row_factory=dict_row. Common questions Why does it work in a script? In a script you usually run the graph inside the async with block, so the connection is still open. Does MemorySaver have this problem? No: the in-memory saver has no connection to close, which is why the app works until you switch to Postgres. Is the checkpointer my agent's long-term memory? It's per-thread state (resume, time travel). Memory across threads is a separate store. If you also need memory across threads The MemorySync LangGraph guide keeps the two apart: thread state stays on a checkpointer such as langgraph-checkpoint-postgres, and MemorySync supplies long-term memory across threads through a LangGraph BaseStore (MemorySyncStore) passed as store=, plus context injection, a persist node and a search tool. It doesn't replace the checkpointer, so the fix above still applies. Read the guide first. To see save and recall in your browser, try the MemorySync playground. Related pages - n8n WhatsApp AI agent memory: which Session ID to use - n8n Postgres Chat Memory: fixing 'Got unexpected type: user' - Codex CLI persistent memory with AGENTS.md and MCP Sources - langchain-ai/langgraph#1292 (closed 2024-08-09; read 2026-10-28) - langgraph libs/checkpoint-postgres/README.md and langgraph/checkpoint/postgres/aio.py, _ainternal.py on main (read 2026-10-28; PyPI latest langgraph-checkpoint-postgres 3.2.0) - MemorySync docs: docs.memorysync.io/guides/langgraph

My browser automation agent is stuck in an endless loop and throwing Pydantic errors, how do I actually fix this? So I tried setting up a LangChain Playwright agent to automate posting to Reddit, and man... it is driving me insane. It starts off fine, navigates to the links, but then it completely loses its mind trying to find input fields. It just keeps looping—retrying get_elements, going back and forth between pages, waiting for 5 seconds over and over again, and getting []every single time. And then to top it all off, it finally crashes completely with a Pydantic validation error (Field required [type=missing, input_value={'element': ...}) because it tried passing weird keys into the click tool instead of a simple CSS selector. Has anyone actually gotten LangChain's tool-calling agent with Playwright to work reliably on modern dynamic sites like Reddit? Or am I missing something obvious about how it handles selectors and page states? Any advice from people who've dealt with this would be awesome. code : from mlx_lm import load, generate import os from dotenv import load_dotenv from langchain.agents import create_agent, AgentState from langchain.messages import HumanMessage, ToolMessage, AIMessage from langchain_core.prompts import PromptTemplate from langchain_community.agent_toolkits import PlayWrightBrowserToolkit from langchain_community.tools.playwright.utils import create_sync_playwright_browser from langchain_core.prompts import ChatPromptTemplate from langchain_ollama import ChatOllama import re from langchain_classic.agents import AgentExecutor, create_tool_calling_agent load_dotenv() model, tokeniser = load("mlx-community/Qwen2.5-7B-Instruct-4bit") system_prompt = """You are a human writing assistant that rewrites a user's raw thoughts into a natural Reddit post. Strict rules you must follow: - Stay extremely faithful to the original message. Do not invent new problems, new details, new causes, or new solutions. - Do not add advice, diagnoses, or explanations the user did not already express. - Keep every important point the user made (the rewinding, the 50-minute pomodoro, the background noise, the feeling of being lost, the endless loop, the self-frustration). - Only elaborate and expand what is already there so it flows like a real person talking. - Make it sound completely human: messy, conversational, slightly self-deprecating, frustrated, and natural. Use contractions, incomplete thoughts, and everyday language. - Avoid any robotic phrasing, corporate words, lists, bullet points, or overly clean structure. - Avoid the use of emojis. - The final post must feel like it was written by the same person who wrote the original message, just cleaned up and expanded a little for Reddit. Output format (very important): Title: <short natural title> Body: <the full reddit post> """ query = '''I m so dumb in studies. i keeps on rewinding the same youtube lecture like 15 times even after setting a pomodoro of 50 minutes and playing background noises. but still i can't seem to focus and ends up being lost once again just to find that i need to watch this same video again. and this loops keeps going. Why does it happen ? and is it possible to stop this ?''' prompt = f"{system_prompt}\n\nUser's raw thoughts: {query}\n\nGenerated Reddit Post:" raw_output = generate( model, tokenizer= tokeniser, prompt=prompt, verbose=False, ) title_match = re.search(r"Title:\s*(.+)", raw_output) body_match = re.search(r"Body:\s*(.*?)(?=\nTitle:|$)", raw_output, re.DOTALL) if title_match: title = title_match.group(1).strip() else: title_prompt = f"""Generate only a short, natural, human-sounding Reddit title for this post. Do not use quotes. Do not write anything else. Just the title. Post: {body}""" title = generate(model,tokenizer=tokeniser,prompt=title_prompt, verbose=False).strip() body = body_match.group(1).strip() if body_match else raw_output print("=== Final Title ===") print(title) print("\n=== Final Body ===") print(body) print("==================\n") #browser automation stuff from playwright.sync_api import sync_playwright playwright_context = sync_playwright().start() browser = playwright_context.chromium.connect_over_cdp("http://localhost:9222") page = browser.contexts[0].pages[0] if browser.contexts[0].pages else browser.contexts[0].new_page() toolkit = PlayWrightBrowserToolkit.from_browser(sync_browser=browser) tools = toolkit.get_tools() llm = ChatOllama( model="qwen2.5:7b", temperature=0.2, ) # Agent prompt prompt = ChatPromptTemplate.from_messages([ ("system", "You are a helpful browser automation assistant. Follow the instructions carefully and use the available tools."), ("human", "{input}"), ("placeholder", "{agent_scratchpad}"), ]) agent = create_tool_calling_agent(llm, tools, prompt) agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) # Change these values SUBREDDIT = "GetStudying" task = f""" 1. Go to old.reddit.com 2. Make sure I am logged in. If not, wait for me to log in manually. 3. After I am logged in, go to https://old.reddit.com/r/{SUBREDDIT}/submit 4. In the title field, type: {title} 5. In the body/text field, paste this exact text: {body} 6. Click the Post button. """ print("Running agent... (you may need to log in manually when the browser opens)") agent_executor.invoke({"input": task}) print("\nDone!") typical terminal output : (web-assist) ➜ web_assist git:(main) ✗ uv run main.py /Users/aradhyabaliyan/code/internship/web_assist/main.py:7: DeprecationWarning: `langchain-community` is being sunset and is no longer actively maintained. See https://github.com/langchain-ai/langchain-community/issues/674 for details and migrationguidance toward standalone integration packages. from langchain_community.agent_toolkits import PlayWrightBrowserToolkit Fetching 9 files: 100%|███████████████████████████| 9/9 [00:00<00:00, 2136.80it/s] Reconstruction complete: | | 0.00B / 0.00B Download complete: | 0.00B === Final Title === Feeling Lost in Studies: Rewind Loop and Pomodoro Frustration === Final Body === Ugh, I feel so dumb sometimes. I set a 50-minute pomodoro timer and play some background noises, but I still can't focus. I end up rewinding the same YouTube lecturelike 15 times, and it's driving me crazy. I thought the background noise would help, but it just makes me feel more lost. I end up watching the same video over and over, and it's like I'm stuck in a never-ending loop. Why does this happen to me? Isit possible to break this cycle? Anyone else out there feeling like this? #studystruggles #pomodorofailure #rewindloop ================== python3(19720) MallocStackLogging: can't turn off malloc stack logging because it was not enabled. Running agent... (you may need to log in manually when the browser opens) > Entering new AgentExecutor chain... Invoking: `navigate_browser` with `{'url': 'https://www.reddit.com'}` Navigating to https://www.reddit.com returned status code 200 Invoking: `click_element` with `{'selector': 'a[href="/r/login"]'}` Unable to click on element 'a[href="/r/login"]' Invoking: `navigate_browser` with `{'url': 'https://www.reddit.com/r/GetStudying/submit'}` responded: It seems that you are already logged in or the login link is not present. Let's proceed to the next step and navigate to the submission page. Navigating to https://www.reddit.com/r/GetStudying/submit returned status code 200 Invoking: `click_element` with `{'selector': 'input[name="title"]'}` responded: Great, we are now on the submission page for the subreddit r/GetStudying. Let's fill out the form. Unable to click on element 'input[name="title"]' Invoking: `get_elements` with `{'selector': "input[name='title'], textarea[name='text']"}` responded: It appears that the title input field is not immediately available or requires some additional interaction. Let's try to find and fill in the title field step by step. First, let's retrieve the elements for the title field and any other relevant fields. [] Invoking: `get_elements` with `{'selector': 'input'}` responded: It seems there are no elements matching the selector for the title field. Let's try a more general approach to find the title input field. Let's retrieve all input fields and see if we can identify the title field. [] Invoking: `get_elements` with `{'selector': 'input[name="title"]'}` responded: It seems that there are no input fields matching the general selector. Let's try a more specific approach to find the title field by using a more targetedCSS selector. Let's retrieve elements with the CSS selector `input[name="title"]` again. [] Invoking: `get_elements` with `{'selector': 'input'}` responded: It appears that the title input field is not being found using the `input[name="title"]` selector. Let's try a different approach to locate the title field. We will retrieve all input fields and inspect their attributes to identify the title field. [] Invoking: `previous_webpage` with `{}` responded: It seems that there are no input fields present on the page at this moment. Let's try navigating back to the previous page and then attempt to find the title field again. Let's navigate back to the previous page. Navigated back to the previous page with URL 'https://www.reddit.com/'. Status code 200 Invoking: `get_elements` with `{'selector': 'input'}` [] Invoking: `navigate_browser` with `{'url': 'https://www.reddit.com/r/GetStudying/submit'}` responded: It seems that there are still no input fields present on the page. Let's try navigating back to the submission page and then attempt to find the title field again. Let's navigate back to the submission page. Navigating to https://www.reddit.com/r/GetStudying/submit returned status code 200 Invoking: `get_elements` with `{'selector': 'input'}` [] Invoking: `previous_webpage` with `{}` responded: It appears that there are still no input fields present on the page. This could be due to the page not fully loading or the elements not being available yet. Let's try waiting a bit and then attempting to find the title field again. Let's wait for 5 seconds and then try again. Navigated back to the previous page with URL 'https://www.reddit.com/'. Status code 200 Invoking: `navigate_browser` with `{'url': 'https://www.reddit.com/r/GetStudying/submit'}` responded: It seems that the page is still not loading the necessary elements. Let's try navigating back to the submission page and then attempt to find the title field again after a short wait. Let's navigate back to the submission page and wait for 5 seconds. Navigating to https://www.reddit.com/r/GetStudying/submit returned status code 200 Invoking: `previous_webpage` with `{}` responded: It seems that the page is still not loading the necessary elements. Let's try navigating back to the submission page and then attempt to find the title field again after a short wait. Let's navigate back to the submission page and wait for 5 seconds. Navigated back to the previous page with URL 'https://www.reddit.com/'. Status code 200 Invoking: `click_element` with `{'selector': "input[name='title']"}` responded: It seems that the page is still not loading the necessary elements. Let's try navigating back to the submission page and then attempt to find the title field again after a short wait. Let's navigate back to the submission page and wait for 5 seconds. Unable to click on element 'input[name='title']' Invoking: `click_element` with `{'element': "input[name='title']", 'text': 'Feeling Lost in Studies: Rewind Loop and Pomodoro Frustration'}` responded: It seems that the page is still not loading the necessary elements. Let's try navigating back to the submission page and then attempt to find the title field again after a short wait. Let's navigate back to the submission page and wait for 5 seconds. Traceback (most recent call last): File "/Users/aradhyabaliyan/code/internship/web_assist/main.py", line 108, in <module> agent_executor.invoke({"input": task}) ~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^ File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/langchain_classic/chains/base.py", line 167, in invoke self._call(inputs, run_manager=run_manager) ~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/langchain_classic/agents/agent.py", line 1590, in _call next_step_output = self._take_next_step( name_to_tool_map, ...<3 lines>... run_manager=run_manager, ) File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/langchain_classic/agents/agent.py", line 1290, in _take_next_step list( ~~~~^ self._iter_next_step( ^^^^^^^^^^^^^^^^^^^^^ ...<5 lines>... ), ^^ ), ^ File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/langchain_classic/agents/agent.py", line 1373, in _iter_next_step yield self._perform_agent_action( ~~~~~~~~~~~~~~~~~~~~~~~~~~^ name_to_tool_map, ^^^^^^^^^^^^^^^^^ ...<2 lines>... run_manager, ^^^^^^^^^^^^ ) ^ File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/langchain_classic/agents/agent.py", line 1398, in _perform_agent_action observation = tool.run( agent_action.tool_input, ...<3 lines>... **tool_run_kwargs, ) File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/langchain_core/tools/base.py", line 1132, in run raise error_to_raise File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/langchain_core/tools/base.py", line 1091, in run tool_args, tool_kwargs = self._to_args_and_kwargs( ~~~~~~~~~~~~~~~~~~~~~~~~^ tool_input, tool_call_id ^^^^^^^^^^^^^^^^^^^^^^^^ ) ^ File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/langchain_core/tools/base.py", line 993, in _to_args_and_kwargs tool_input = self._parse_input(tool_input, tool_call_id) File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/langchain_core/tools/base.py", line 834, in _parse_input result_v2 = input_args.model_validate(tool_input) File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/pydantic/main.py", line 790, in model_validate return cls.__pydantic_validator__.validate_python( ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^ obj, ^^^^ ...<5 lines>... by_name=by_name, ^^^^^^^^^^^^^^^^ ) ^ pydantic_core._pydantic_core.ValidationError: 1 validation error for ClickToolInput selector Field required [type=missing, input_value={'element': "input[name='...d PomodoroFrustration'}, input_type=dict] For further information visit https://errors.pydantic.dev/2.14/v/missing (web-assist) ➜ web_assist git:(main) ✗ uv run main.py /Users/aradhyabaliyan/code/internship/web_assist/main.py:7: DeprecationWarning: `langchain-community` is being sunset and is no longer actively maintained. See https://github.com/langchain-ai/langchain-community/issues/674 for details and migrationguidance toward standalone integration packages. from langchain_community.agent_toolkits import PlayWrightBrowserToolkit Fetching 9 files: 100%|███████████████████████████| 9/9 [00:00<00:00, 1666.10it/s] Reconstruction complete: | | 0.00B / 0.00B Download complete: | 0.00B === Final Title === Feeling Lost in Studies: Rewind Loop and Pomodoro Frustration === Final Body === Ugh, I feel so dumb sometimes. I set a 50-minute pomodoro timer and play some background noises, but I still can't focus. I end up rewinding the same YouTube lecturelike 15 times, and it's driving me crazy. I thought the background noise would help, but it just makes me feel more lost. I end up watching the same video over and over, and it's like I'm stuck in a never-ending loop. Why does this happen to me? Isit possible to break this cycle? Anyone else out there feeling like this? #studystruggles #pomodorofailure #rewindloop ================== Running agent... (you may need to log in manually when the browser opens) > Entering new AgentExecutor chain... Invoking: `navigate_browser` with `{'url': 'https://old.reddit.com'}` Navigating to https://old.reddit.com returned status code 200 Invoking: `navigate_browser` with `{'url': 'https://old.reddit.com/r/GetStudying/submit'}` Navigating to https://old.reddit.com/r/GetStudying/submit returned status code 200 Invoking: `click_element` with `{'selector': "a[href='/r/GetStudying/submit']"}` Unable to click on element 'a[href='/r/GetStudying/submit']' Invoking: `click_element` with `{'selector': "input[name='title']"}` Unable to click on element 'input[name='title']' Invoking: `get_elements` with `{'selector': "input[name='title'], textarea[name='text'], button[type='submit']"}` responded: It seems there was an issue with clicking the elements directly. Let's try a different approach to ensure we are interacting with the correct elements on the page. We will first extract the text fields and buttons to ensure we are targeting the right ones. Let's start by extracting the text fields and the post button. [{"innerText": "save"}, {"innerText": "submit"}] Invoking: `get_elements` with `{'selector': "input[name='title'], textarea[name='text'], button:contains('submit')"}` Traceback (most recent call last): File "/Users/aradhyabaliyan/code/internship/web_assist/main.py", line 108, in <module> agent_executor.invoke({"input": task}) ~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^ File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/langchain_classic/chains/base.py", line 167, in invoke self._call(inputs, run_manager=run_manager) ~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/langchain_classic/agents/agent.py", line 1590, in _call next_step_output = self._take_next_step( name_to_tool_map, ...<3 lines>... run_manager=run_manager, ) File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/langchain_classic/agents/agent.py", line 1290, in _take_next_step list( ~~~~^ self._iter_next_step( ^^^^^^^^^^^^^^^^^^^^^ ...<5 lines>... ), ^^ ), ^ File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/langchain_classic/agents/agent.py", line 1373, in _iter_next_step yield self._perform_agent_action( ~~~~~~~~~~~~~~~~~~~~~~~~~~^ name_to_tool_map, ^^^^^^^^^^^^^^^^^ ...<2 lines>... run_manager, ^^^^^^^^^^^^ ) ^ File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/langchain_classic/agents/agent.py", line 1398, in _perform_agent_action observation = tool.run( agent_action.tool_input, ...<3 lines>... **tool_run_kwargs, ) File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/langchain_core/tools/base.py", line 1132, in run raise error_to_raise File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/langchain_core/tools/base.py", line 1098, in run response = context.run(self._run, *tool_args, **tool_kwargs) File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/langchain_community/tools/playwright/get_elements.py", line 96, in _run results = _get_elements(page, selector, attributes) File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/langchain_community/tools/playwright/get_elements.py", line 60, in _get_elements elements = page.query_selector_all(selector) File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/playwright/sync_api/_generated.py", line 19843, in query_selector_all self._sync(self._impl_obj.query_selector_all(selector=selector)) ~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/playwright/_impl/_sync_base.py", line 111, in _sync return task.result() ~~~~~~~~~~~^^ File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/playwright/_impl/_page.py", line 422, in query_selector_all return await self._main_frame.query_selector_all(selector) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/playwright/_impl/_frame.py", line 381, in query_selector_all await self._channel.send( ^^^^^^^^^^^^^^^^^^^^^^^^^ "querySelectorAll", None, dict(selector=selector) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ), ^ File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/playwright/_impl/_connection.py", line 78, in send return await self._connection.wrap_api_call( ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...<3 lines>... ) ^ File "/Users/aradhyabaliyan/code/internship/web_assist/.venv/lib/python3.14/site-packages/playwright/_impl/_connection.py", line 636, in wrap_api_call raise rewrite_error(error, f"{parsed_st['apiName']}: {error}") from None playwright._impl._errors.Error: Page.query_selector_all: SyntaxError: Failed to execute 'querySelectorAll' on 'Document': 'button:contains("submit")' is not a valid selector. at query (<anonymous>:5817:41) at <anonymous>:5827:7 at SelectorEvaluatorImpl._cached (<anonymous>:5604:20) at SelectorEvaluatorImpl._queryCSS (<anonymous>:5814:17) at SelectorEvaluatorImpl._querySimple (<anonymous>:5694:19) at <anonymous>:5642:29 at SelectorEvaluatorImpl._cached (<anonymous>:5604:20) at SelectorEvaluatorImpl.query (<anonymous>:5635:19) at Object.query (<anonymous>:5849:44) at <anonymous>:5807:21 (web-assist) ➜ web_assist git:(main) ✗ im running this in Mac M1 Air (8GB RAM) with Golden Gate. Suggestions are welcome !

How does issue assignment work in LangChain? Can contributors start working without being assigned? I'm trying to make my first contribution to LangChain. I opened an issue (#41534) about InMemoryVectorStore accepting an empty ID list for non-empty documents, and I commented with my proposed fix and tests. I've noticed that LangChain has a contribution process where issues need maintainer approval/assignment before opening a PR. I'm a bit confused about how this works in practice, though. - Should I wait for a maintainer to explicitly assign the issue to me before starting any implementation? - If nobody responds or assigns it, is there a recommended way to follow up? - Is there anything useful I can do in the meantime, such as investigating existing tests, without risking having a PR automatically closed? I want to follow the project's process properly rather than start work that can't be submitted. I'd appreciate hearing from people who've contributed to LangChain before. Thanks!

Get started with Content Studio: langchain-ai/design-agent