[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7BWH0M512QFE3FHKGC6F59V":3,"skill-same:01M7BWH0M512QFE3FHKGC6F59V":47},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":24,"commitSha":25,"skillDirectory":26,"forksCount":27,"repositoryHtmlUrl":28,"repositoryHomepageUrl":29,"ownerHtmlUrl":30,"ownerBlogUrl":6,"ownerDescription":31,"updatedAt":32,"install":33,"resources":46},"01M7BWH0M512QFE3FHKGC6F59V","langchain-architecture",null,"Design LLM applications using LangChain 1.x and LangGraph for agents, memory, and tool integration. Use when building LangChain applications, implementing AI agents, or creating complex LLM workflows.","YYC-Cube\u002FYYC3-Knowledge-Base","YYC-Cube","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F235006543?v=4","01M79J2PH4SWD2X0825X6PN748","yyc3","01M79J2PHVK3F6ZBYT8K2SCZCW",1,"MIT","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-Plugin-插件协议\u002FYYC3-Plugin-插件协议-plugins-claude\u002Fllm-application-dev\u002Fskills\u002Flangchain-architecture\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: langchain-architecture\ndescription: Design LLM applications using LangChain 1.x and LangGraph for agents, memory, and tool integration. Use when building LangChain applications, implementing AI agents, or creating complex LLM workflows.\n---\n\n# LangChain & LangGraph Architecture\n\nMaster modern LangChain 1.x and LangGraph for building sophisticated LLM applications with agents, state management, memory, and tool integration.\n\n## When to Use This Skill\n\n- Building autonomous AI agents with tool access\n- Implementing complex multi-step LLM workflows\n- Managing conversation memory and state\n- Integrating LLMs with external data sources and APIs\n- Creating modular, reusable LLM application components\n- Implementing document processing pipelines\n- Building production-grade LLM applications\n\n## Package Structure (LangChain 1.x)\n\n```\nlangchain (1.2.x)         # High-level orchestration\nlangchain-core (1.2.x)    # Core abstractions (messages, prompts, tools)\nlangchain-community       # Third-party integrations\nlanggraph                 # Agent orchestration and state management\nlangchain-openai          # OpenAI integrations\nlangchain-anthropic       # Anthropic\u002FClaude integrations\nlangchain-voyageai        # Voyage AI embeddings\nlangchain-pinecone        # Pinecone vector store\n```\n\n## Core Concepts\n\n### 1. LangGraph Agents\n\nLangGraph is the standard for building agents in 2026. It provides:\n\n**Key Features:**\n\n- **StateGraph**: Explicit state management with typed state\n- **Durable Execution**: Agents persist through failures\n- **Human-in-the-Loop**: Inspect and modify state at any point\n- **Memory**: Short-term and long-term memory across sessions\n- **Checkpointing**: Save and resume agent state\n\n**Agent Patterns:**\n\n- **ReAct**: Reasoning + Acting with `create_react_agent`\n- **Plan-and-Execute**: Separate planning and execution nodes\n- **Multi-Agent**: Supervisor routing between specialized agents\n- **Tool-Calling**: Structured tool invocation with Pydantic schemas\n\n### 2. State Management\n\nLangGraph uses TypedDict for explicit state:\n\n```python\nfrom typing import Annotated, TypedDict\nfrom langgraph.graph import MessagesState\n\n# Simple message-based state\nclass AgentState(MessagesState):\n    \"\"\"Extends MessagesState with custom fields.\"\"\"\n    context: Annotated[list, \"retrieved documents\"]\n\n# Custom state for complex agents\nclass CustomState(TypedDict):\n    messages: Annotated[list, \"conversation history\"]\n    context: Annotated[dict, \"retrieved context\"]\n    current_step: str\n    results: list\n```\n\n### 3. Memory Systems\n\nModern memory implementations:\n\n- **ConversationBufferMemory**: Stores all messages (short conversations)\n- **ConversationSummaryMemory**: Summarizes older messages (long conversations)\n- **ConversationTokenBufferMemory**: Token-based windowing\n- **VectorStoreRetrieverMemory**: Semantic similarity retrieval\n- **LangGraph Checkpointers**: Persistent state across sessions\n\n### 4. Document Processing\n\nLoading, transforming, and storing documents:\n\n**Components:**\n\n- **Document Loaders**: Load from various sources\n- **Text Splitters**: Chunk documents intelligently\n- **Vector Stores**: Store and retrieve embeddings\n- **Retrievers**: Fetch relevant documents\n\n### 5. Callbacks & Tracing\n\nLangSmith is the standard for observability:\n\n- Request\u002Fresponse logging\n- Token usage tracking\n- Latency monitoring\n- Error tracking\n- Trace visualization\n\n## Quick Start\n\n### Modern ReAct Agent with LangGraph\n\n```python\nfrom langgraph.prebuilt import create_react_agent\nfrom langgraph.checkpoint.memory import MemorySaver\nfrom langchain_anthropic import ChatAnthropic\nfrom langchain_core.tools import tool\nimport ast\nimport operator\n\n# Initialize LLM (Claude Sonnet 4.6 recommended)\nllm = ChatAnthropic(model=\"claude-sonnet-4-6\", temperature=0)\n\n# Define tools with Pydantic schemas\n@tool\ndef search_database(query: str) -> str:\n    \"\"\"Search internal database for information.\"\"\"\n    # Your database search logic\n    return f\"Results for: {query}\"\n\n@tool\ndef calculate(expression: str) -> str:\n    \"\"\"Safely evaluate a mathematical expression.\n\n    Supports: +, -, *, \u002F, **, %, parentheses\n    Example: '(2 + 3) * 4' returns '20'\n    \"\"\"\n    # Safe math evaluation using ast\n    allowed_operators = {\n        ast.Add: operator.add,\n        ast.Sub: operator.sub,\n        ast.Mult: operator.mul,\n        ast.Div: operator.truediv,\n        ast.Pow: operator.pow,\n        ast.Mod: operator.mod,\n        ast.USub: operator.neg,\n    }\n\n    def _eval(node):\n        if isinstance(node, ast.Constant):\n            return node.value\n        elif isinstance(node, ast.BinOp):\n            left = _eval(node.left)\n            right = _eval(node.right)\n            return allowed_operators[type(node.op)](left, right)\n        elif isinstance(node, ast.UnaryOp):\n            operand = _eval(node.operand)\n            return allowed_operators[type(node.op)](operand)\n        else:\n            raise ValueError(f\"Unsupported operation: {type(node)}\")\n\n    try:\n        tree = ast.parse(expression, mode='eval')\n        return str(_eval(tree.body))\n    except Exception as e:\n        return f\"Error: {e}\"\n\ntools = [search_database, calculate]\n\n# Create checkpointer for memory persistence\ncheckpointer = MemorySaver()\n\n# Create ReAct agent\nagent = create_react_agent(\n    llm,\n    tools,\n    checkpointer=checkpointer\n)\n\n# Run agent with thread ID for memory\nconfig = {\"configurable\": {\"thread_id\": \"user-123\"}}\nresult = await agent.ainvoke(\n    {\"messages\": [(\"user\", \"Search for Python tutorials and calculate 25 * 4\")]},\n    config=config\n)\n```\n\n## Architecture Patterns\n\n### Pattern 1: RAG with LangGraph\n\n```python\nfrom langgraph.graph import StateGraph, START, END\nfrom langchain_anthropic import ChatAnthropic\nfrom langchain_voyageai import VoyageAIEmbeddings\nfrom langchain_pinecone import PineconeVectorStore\nfrom langchain_core.documents import Document\nfrom langchain_core.prompts import ChatPromptTemplate\nfrom typing import TypedDict, Annotated\n\nclass RAGState(TypedDict):\n    question: str\n    context: Annotated[list[Document], \"retrieved documents\"]\n    answer: str\n\n# Initialize components\nllm = ChatAnthropic(model=\"claude-sonnet-4-6\")\nembeddings = VoyageAIEmbeddings(model=\"voyage-3-large\")\nvectorstore = PineconeVectorStore(index_name=\"docs\", embedding=embeddings)\nretriever = vectorstore.as_retriever(search_kwargs={\"k\": 4})\n\n# Define nodes\nasync def retrieve(state: RAGState) -> RAGState:\n    \"\"\"Retrieve relevant documents.\"\"\"\n    docs = await retriever.ainvoke(state[\"question\"])\n    return {\"context\": docs}\n\nasync def generate(state: RAGState) -> RAGState:\n    \"\"\"Generate answer from context.\"\"\"\n    prompt = ChatPromptTemplate.from_template(\n        \"\"\"Answer based on the context below. If you cannot answer, say so.\n\n        Context: {context}\n\n        Question: {question}\n\n        Answer:\"\"\"\n    )\n    context_text = \"\\n\\n\".join(doc.page_content for doc in state[\"context\"])\n    response = await llm.ainvoke(\n        prompt.format(context=context_text, question=state[\"question\"])\n    )\n    return {\"answer\": response.content}\n\n# Build graph\nbuilder = StateGraph(RAGState)\nbuilder.add_node(\"retrieve\", retrieve)\nbuilder.add_node(\"generate\", generate)\nbuilder.add_edge(START, \"retrieve\")\nbuilder.add_edge(\"retrieve\", \"generate\")\nbuilder.add_edge(\"generate\", END)\n\nrag_chain = builder.compile()\n\n# Use the chain\nresult = await rag_chain.ainvoke({\"question\": \"What is the main topic?\"})\n```\n\n### Pattern 2: Custom Agent with Structured Tools\n\n```python\nfrom langchain_core.tools import StructuredTool\nfrom pydantic import BaseModel, Field\n\nclass SearchInput(BaseModel):\n    \"\"\"Input for database search.\"\"\"\n    query: str = Field(description=\"Search query\")\n    filters: dict = Field(default={}, description=\"Optional filters\")\n\nclass EmailInput(BaseModel):\n    \"\"\"Input for sending email.\"\"\"\n    recipient: str = Field(description=\"Email recipient\")\n    subject: str = Field(description=\"Email subject\")\n    content: str = Field(description=\"Email body\")\n\nasync def search_database(query: str, filters: dict = {}) -> str:\n    \"\"\"Search internal database for information.\"\"\"\n    # Your database search logic\n    return f\"Results for '{query}' with filters {filters}\"\n\nasync def send_email(recipient: str, subject: str, content: str) -> str:\n    \"\"\"Send an email to specified recipient.\"\"\"\n    # Email sending logic\n    return f\"Email sent to {recipient}\"\n\ntools = [\n    StructuredTool.from_function(\n        coroutine=search_database,\n        name=\"search_database\",\n        description=\"Search internal database\",\n        args_schema=SearchInput\n    ),\n    StructuredTool.from_function(\n        coroutine=send_email,\n        name=\"send_email\",\n        description=\"Send an email\",\n        args_schema=EmailInput\n    )\n]\n\nagent = create_react_agent(llm, tools)\n```\n\n### Pattern 3: Multi-Step Workflow with StateGraph\n\n```python\nfrom langgraph.graph import StateGraph, START, END\nfrom typing import TypedDict, Literal\n\nclass WorkflowState(TypedDict):\n    text: str\n    entities: list\n    analysis: str\n    summary: str\n    current_step: str\n\nasync def extract_entities(state: WorkflowState) -> WorkflowState:\n    \"\"\"Extract key entities from text.\"\"\"\n    prompt = f\"Extract key entities from: {state['text']}\\n\\nReturn as JSON list.\"\n    response = await llm.ainvoke(prompt)\n    return {\"entities\": response.content, \"current_step\": \"analyze\"}\n\nasync def analyze_entities(state: WorkflowState) -> WorkflowState:\n    \"\"\"Analyze extracted entities.\"\"\"\n    prompt = f\"Analyze these entities: {state['entities']}\\n\\nProvide insights.\"\n    response = await llm.ainvoke(prompt)\n    return {\"analysis\": response.content, \"current_step\": \"summarize\"}\n\nasync def generate_summary(state: WorkflowState) -> WorkflowState:\n    \"\"\"Generate final summary.\"\"\"\n    prompt = f\"\"\"Summarize:\n    Entities: {state['entities']}\n    Analysis: {state['analysis']}\n\n    Provide a concise summary.\"\"\"\n    response = await llm.ainvoke(prompt)\n    return {\"summary\": response.content, \"current_step\": \"complete\"}\n\ndef route_step(state: WorkflowState) -> Literal[\"analyze\", \"summarize\", \"end\"]:\n    \"\"\"Route to next step based on current state.\"\"\"\n    step = state.get(\"current_step\", \"extract\")\n    if step == \"analyze\":\n        return \"analyze\"\n    elif step == \"summarize\":\n        return \"summarize\"\n    return \"end\"\n\n# Build workflow\nbuilder = StateGraph(WorkflowState)\nbuilder.add_node(\"extract\", extract_entities)\nbuilder.add_node(\"analyze\", analyze_entities)\nbuilder.add_node(\"summarize\", generate_summary)\n\nbuilder.add_edge(START, \"extract\")\nbuilder.add_conditional_edges(\"extract\", route_step, {\n    \"analyze\": \"analyze\",\n    \"summarize\": \"summarize\",\n    \"end\": END\n})\nbuilder.add_conditional_edges(\"analyze\", route_step, {\n    \"summarize\": \"summarize\",\n    \"end\": END\n})\nbuilder.add_edge(\"summarize\", END)\n\nworkflow = builder.compile()\n```\n\n### Pattern 4: Multi-Agent Orchestration\n\n```python\nfrom langgraph.graph import StateGraph, START, END\nfrom langgraph.prebuilt import create_react_agent\nfrom langchain_core.messages import HumanMessage\nfrom typing import Literal\n\nclass MultiAgentState(TypedDict):\n    messages: list\n    next_agent: str\n\n# Create specialized agents\nresearcher = create_react_agent(llm, research_tools)\nwriter = create_react_agent(llm, writing_tools)\nreviewer = create_react_agent(llm, review_tools)\n\nasync def supervisor(state: MultiAgentState) -> MultiAgentState:\n    \"\"\"Route to appropriate agent based on task.\"\"\"\n    prompt = f\"\"\"Based on the conversation, which agent should handle this?\n\n    Options:\n    - researcher: For finding information\n    - writer: For creating content\n    - reviewer: For reviewing and editing\n    - FINISH: Task is complete\n\n    Messages: {state['messages']}\n\n    Respond with just the agent name.\"\"\"\n\n    response = await llm.ainvoke(prompt)\n    return {\"next_agent\": response.content.strip().lower()}\n\ndef route_to_agent(state: MultiAgentState) -> Literal[\"researcher\", \"writer\", \"reviewer\", \"end\"]:\n    \"\"\"Route based on supervisor decision.\"\"\"\n    next_agent = state.get(\"next_agent\", \"\").lower()\n    if next_agent == \"finish\":\n        return \"end\"\n    return next_agent if next_agent in [\"researcher\", \"writer\", \"reviewer\"] else \"end\"\n\n# Build multi-agent graph\nbuilder = StateGraph(MultiAgentState)\nbuilder.add_node(\"supervisor\", supervisor)\nbuilder.add_node(\"researcher\", researcher)\nbuilder.add_node(\"writer\", writer)\nbuilder.add_node(\"reviewer\", reviewer)\n\nbuilder.add_edge(START, \"supervisor\")\nbuilder.add_conditional_edges(\"supervisor\", route_to_agent, {\n    \"researcher\": \"researcher\",\n    \"writer\": \"writer\",\n    \"reviewer\": \"reviewer\",\n    \"end\": END\n})\n\n# Each agent returns to supervisor\nfor agent in [\"researcher\", \"writer\", \"reviewer\"]:\n    builder.add_edge(agent, \"supervisor\")\n\nmulti_agent = builder.compile()\n```\n\n## Memory Management\n\n### Token-Based Memory with LangGraph\n\n```python\nfrom langgraph.checkpoint.memory import MemorySaver\nfrom langgraph.prebuilt import create_react_agent\n\n# In-memory checkpointer (development)\ncheckpointer = MemorySaver()\n\n# Create agent with persistent memory\nagent = create_react_agent(llm, tools, checkpointer=checkpointer)\n\n# Each thread_id maintains separate conversation\nconfig = {\"configurable\": {\"thread_id\": \"session-abc123\"}}\n\n# Messages persist across invocations with same thread_id\nresult1 = await agent.ainvoke({\"messages\": [(\"user\", \"My name is Alice\")]}, config)\nresult2 = await agent.ainvoke({\"messages\": [(\"user\", \"What's my name?\")]}, config)\n# Agent remembers: \"Your name is Alice\"\n```\n\n### Production Memory with PostgreSQL\n\n```python\nfrom langgraph.checkpoint.postgres import PostgresSaver\n\n# Production checkpointer\ncheckpointer = PostgresSaver.from_conn_string(\n    \"postgresql:\u002F\u002Fuser:pass@localhost\u002Flanggraph\"\n)\n\nagent = create_react_agent(llm, tools, checkpointer=checkpointer)\n```\n\n### Vector Store Memory for Long-Term Context\n\n```python\nfrom langchain_community.vectorstores import Chroma\nfrom langchain_voyageai import VoyageAIEmbeddings\n\nembeddings = VoyageAIEmbeddings(model=\"voyage-3-large\")\nmemory_store = Chroma(\n    collection_name=\"conversation_memory\",\n    embedding_function=embeddings,\n    persist_directory=\".\u002Fmemory_db\"\n)\n\nasync def retrieve_relevant_memory(query: str, k: int = 5) -> list:\n    \"\"\"Retrieve relevant past conversations.\"\"\"\n    docs = await memory_store.asimilarity_search(query, k=k)\n    return [doc.page_content for doc in docs]\n\nasync def store_memory(content: str, metadata: dict = {}):\n    \"\"\"Store conversation in long-term memory.\"\"\"\n    await memory_store.aadd_texts([content], metadatas=[metadata])\n```\n\n## Callback System & LangSmith\n\n### LangSmith Tracing\n\n```python\nimport os\nfrom langchain_anthropic import ChatAnthropic\n\n# Enable LangSmith tracing\nos.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\nos.environ[\"LANGCHAIN_API_KEY\"] = \"your-api-key\"\nos.environ[\"LANGCHAIN_PROJECT\"] = \"my-project\"\n\n# All LangChain\u002FLangGraph operations are automatically traced\nllm = ChatAnthropic(model=\"claude-sonnet-4-6\")\n```\n\n### Custom Callback Handler\n\n```python\nfrom langchain_core.callbacks import BaseCallbackHandler\nfrom typing import Any, Dict, List\n\nclass CustomCallbackHandler(BaseCallbackHandler):\n    def on_llm_start(\n        self, serialized: Dict[str, Any], prompts: List[str], **kwargs\n    ) -> None:\n        print(f\"LLM started with {len(prompts)} prompts\")\n\n    def on_llm_end(self, response, **kwargs) -> None:\n        print(f\"LLM completed: {len(response.generations)} generations\")\n\n    def on_llm_error(self, error: Exception, **kwargs) -> None:\n        print(f\"LLM error: {error}\")\n\n    def on_tool_start(\n        self, serialized: Dict[str, Any], input_str: str, **kwargs\n    ) -> None:\n        print(f\"Tool started: {serialized.get('name')}\")\n\n    def on_tool_end(self, output: str, **kwargs) -> None:\n        print(f\"Tool completed: {output[:100]}...\")\n\n# Use callbacks\nresult = await agent.ainvoke(\n    {\"messages\": [(\"user\", \"query\")]},\n    config={\"callbacks\": [CustomCallbackHandler()]}\n)\n```\n\n## Streaming Responses\n\n```python\nfrom langchain_anthropic import ChatAnthropic\n\nllm = ChatAnthropic(model=\"claude-sonnet-4-6\", streaming=True)\n\n# Stream tokens\nasync for chunk in llm.astream(\"Tell me a story\"):\n    print(chunk.content, end=\"\", flush=True)\n\n# Stream agent events\nasync for event in agent.astream_events(\n    {\"messages\": [(\"user\", \"Search and summarize\")]},\n    version=\"v2\"\n):\n    if event[\"event\"] == \"on_chat_model_stream\":\n        print(event[\"data\"][\"chunk\"].content, end=\"\")\n    elif event[\"event\"] == \"on_tool_start\":\n        print(f\"\\n[Using tool: {event['name']}]\")\n```\n\n## Testing Strategies\n\n```python\nimport pytest\nfrom unittest.mock import AsyncMock, patch\n\n@pytest.mark.asyncio\nasync def test_agent_tool_selection():\n    \"\"\"Test agent selects correct tool.\"\"\"\n    with patch.object(llm, 'ainvoke') as mock_llm:\n        mock_llm.return_value = AsyncMock(content=\"Using search_database\")\n\n        result = await agent.ainvoke({\n            \"messages\": [(\"user\", \"search for documents\")]\n        })\n\n        # Verify tool was called\n        assert \"search_database\" in str(result)\n\n@pytest.mark.asyncio\nasync def test_memory_persistence():\n    \"\"\"Test memory persists across invocations.\"\"\"\n    config = {\"configurable\": {\"thread_id\": \"test-thread\"}}\n\n    # First message\n    await agent.ainvoke(\n        {\"messages\": [(\"user\", \"Remember: the code is 12345\")]},\n        config\n    )\n\n    # Second message should remember\n    result = await agent.ainvoke(\n        {\"messages\": [(\"user\", \"What was the code?\")]},\n        config\n    )\n\n    assert \"12345\" in result[\"messages\"][-1].content\n```\n\n## Performance Optimization\n\n### 1. Caching with Redis\n\n```python\nfrom langchain_community.cache import RedisCache\nfrom langchain_core.globals import set_llm_cache\nimport redis\n\nredis_client = redis.Redis.from_url(\"redis:\u002F\u002Flocalhost:6379\")\nset_llm_cache(RedisCache(redis_client))\n```\n\n### 2. Async Batch Processing\n\n```python\nimport asyncio\nfrom langchain_core.documents import Document\n\nasync def process_documents(documents: list[Document]) -> list:\n    \"\"\"Process documents in parallel.\"\"\"\n    tasks = [process_single(doc) for doc in documents]\n    return await asyncio.gather(*tasks)\n\nasync def process_single(doc: Document) -> dict:\n    \"\"\"Process a single document.\"\"\"\n    chunks = text_splitter.split_documents([doc])\n    embeddings = await embeddings_model.aembed_documents(\n        [c.page_content for c in chunks]\n    )\n    return {\"doc_id\": doc.metadata.get(\"id\"), \"embeddings\": embeddings}\n```\n\n### 3. Connection Pooling\n\n```python\nfrom langchain_pinecone import PineconeVectorStore\nfrom pinecone import Pinecone\n\n# Reuse Pinecone client\npc = Pinecone(api_key=os.environ[\"PINECONE_API_KEY\"])\nindex = pc.Index(\"my-index\")\n\n# Create vector store with existing index\nvectorstore = PineconeVectorStore(index=index, embedding=embeddings)\n```\n","# LangChain & LangGraph Architecture\n\nMaster modern LangChain 1.x and LangGraph for building sophisticated LLM applications with agents, state management, memory, and tool integration.\n\n## When to Use This Skill\n\n- Building autonomous AI agents with tool access\n- Implementing complex multi-step LLM workflows\n- Managing conversation memory and state\n- Integrating LLMs with external data sources and APIs\n- Creating modular, reusable LLM application components\n- Implementing document processing pipelines\n- Building production-grade LLM applications\n\n## Package Structure (LangChain 1.x)\n\n```\nlangchain (1.2.x)         # High-level orchestration\nlangchain-core (1.2.x)    # Core abstractions (messages, prompts, tools)\nlangchain-community       # Third-party integrations\nlanggraph                 # Agent orchestration and state management\nlangchain-openai          # OpenAI integrations\nlangchain-anthropic       # Anthropic\u002FClaude integrations\nlangchain-voyageai        # Voyage AI embeddings\nlangchain-pinecone        # Pinecone vector store\n```\n\n## Core Concepts\n\n### 1. LangGraph Agents\n\nLangGraph is the standard for building agents in 2026. It provides:\n\n**Key Features:**\n\n- **StateGraph**: Explicit state management with typed state\n- **Durable Execution**: Agents persist through failures\n- **Human-in-the-Loop**: Inspect and modify state at any point\n- **Memory**: Short-term and long-term memory across sessions\n- **Checkpointing**: Save and resume agent state\n\n**Agent Patterns:**\n\n- **ReAct**: Reasoning + Acting with `create_react_agent`\n- **Plan-and-Execute**: Separate planning and execution nodes\n- **Multi-Agent**: Supervisor routing between specialized agents\n- **Tool-Calling**: Structured tool invocation with Pydantic schemas\n\n### 2. State Management\n\nLangGraph uses TypedDict for explicit state:\n\n```python\nfrom typing import Annotated, TypedDict\nfrom langgraph.graph import MessagesState\n\n# Simple message-based state\nclass AgentState(MessagesState):\n    \"\"\"Extends MessagesState with custom fields.\"\"\"\n    context: Annotated[list, \"retrieved documents\"]\n\n# Custom state for complex agents\nclass CustomState(TypedDict):\n    messages: Annotated[list, \"conversation history\"]\n    context: Annotated[dict, \"retrieved context\"]\n    current_step: str\n    results: list\n```\n\n### 3. Memory Systems\n\nModern memory implementations:\n\n- **ConversationBufferMemory**: Stores all messages (short conversations)\n- **ConversationSummaryMemory**: Summarizes older messages (long conversations)\n- **ConversationTokenBufferMemory**: Token-based windowing\n- **VectorStoreRetrieverMemory**: Semantic similarity retrieval\n- **LangGraph Checkpointers**: Persistent state across sessions\n\n### 4. Document Processing\n\nLoading, transforming, and storing documents:\n\n**Components:**\n\n- **Document Loaders**: Load from various sources\n- **Text Splitters**: Chunk documents intelligently\n- **Vector Stores**: Store and retrieve embeddings\n- **Retrievers**: Fetch relevant documents\n\n### 5. Callbacks & Tracing\n\nLangSmith is the standard for observability:\n\n- Request\u002Fresponse logging\n- Token usage tracking\n- Latency monitoring\n- Error tracking\n- Trace visualization\n\n## Quick Start\n\n### Modern ReAct Agent with LangGraph\n\n```python\nfrom langgraph.prebuilt import create_react_agent\nfrom langgraph.checkpoint.memory import MemorySaver\nfrom langchain_anthropic import ChatAnthropic\nfrom langchain_core.tools import tool\nimport ast\nimport operator\n\n# Initialize LLM (Claude Sonnet 4.6 recommended)\nllm = ChatAnthropic(model=\"claude-sonnet-4-6\", temperature=0)\n\n# Define tools with Pydantic schemas\n@tool\ndef search_database(query: str) -> str:\n    \"\"\"Search internal database for information.\"\"\"\n    # Your database search logic\n    return f\"Results for: {query}\"\n\n@tool\ndef calculate(expression: str) -> str:\n    \"\"\"Safely evaluate a mathematical expression.\n\n    Supports: +, -, *, \u002F, **, %, parentheses\n    Example: '(2 + 3) * 4' returns '20'\n    \"\"\"\n    # Safe math evaluation using ast\n    allowed_operators = {\n        ast.Add: operator.add,\n        ast.Sub: operator.sub,\n        ast.Mult: operator.mul,\n        ast.Div: operator.truediv,\n        ast.Pow: operator.pow,\n        ast.Mod: operator.mod,\n        ast.USub: operator.neg,\n    }\n\n    def _eval(node):\n        if isinstance(node, ast.Constant):\n            return node.value\n        elif isinstance(node, ast.BinOp):\n            left = _eval(node.left)\n            right = _eval(node.right)\n            return allowed_operators[type(node.op)](left, right)\n        elif isinstance(node, ast.UnaryOp):\n            operand = _eval(node.operand)\n            return allowed_operators[type(node.op)](operand)\n        else:\n            raise ValueError(f\"Unsupported operation: {type(node)}\")\n\n    try:\n        tree = ast.parse(expression, mode='eval')\n        return str(_eval(tree.body))\n    except Exception as e:\n        return f\"Error: {e}\"\n\ntools = [search_database, calculate]\n\n# Create checkpointer for memory persistence\ncheckpointer = MemorySaver()\n\n# Create ReAct agent\nagent = create_react_agent(\n    llm,\n    tools,\n    checkpointer=checkpointer\n)\n\n# Run agent with thread ID for memory\nconfig = {\"configurable\": {\"thread_id\": \"user-123\"}}\nresult = await agent.ainvoke(\n    {\"messages\": [(\"user\", \"Search for Python tutorials and calculate 25 * 4\")]},\n    config=config\n)\n```\n\n## Architecture Patterns\n\n### Pattern 1: RAG with LangGraph\n\n```python\nfrom langgraph.graph import StateGraph, START, END\nfrom langchain_anthropic import ChatAnthropic\nfrom langchain_voyageai import VoyageAIEmbeddings\nfrom langchain_pinecone import PineconeVectorStore\nfrom langchain_core.documents import Document\nfrom langchain_core.prompts import ChatPromptTemplate\nfrom typing import TypedDict, Annotated\n\nclass RAGState(TypedDict):\n    question: str\n    context: Annotated[list[Document], \"retrieved documents\"]\n    answer: str\n\n# Initialize components\nllm = ChatAnthropic(model=\"claude-sonnet-4-6\")\nembeddings = VoyageAIEmbeddings(model=\"voyage-3-large\")\nvectorstore = PineconeVectorStore(index_name=\"docs\", embedding=embeddings)\nretriever = vectorstore.as_retriever(search_kwargs={\"k\": 4})\n\n# Define nodes\nasync def retrieve(state: RAGState) -> RAGState:\n    \"\"\"Retrieve relevant documents.\"\"\"\n    docs = await retriever.ainvoke(state[\"question\"])\n    return {\"context\": docs}\n\nasync def generate(state: RAGState) -> RAGState:\n    \"\"\"Generate answer from context.\"\"\"\n    prompt = ChatPromptTemplate.from_template(\n        \"\"\"Answer based on the context below. If you cannot answer, say so.\n\n        Context: {context}\n\n        Question: {question}\n\n        Answer:\"\"\"\n    )\n    context_text = \"\\n\\n\".join(doc.page_content for doc in state[\"context\"])\n    response = await llm.ainvoke(\n        prompt.format(context=context_text, question=state[\"question\"])\n    )\n    return {\"answer\": response.content}\n\n# Build graph\nbuilder = StateGraph(RAGState)\nbuilder.add_node(\"retrieve\", retrieve)\nbuilder.add_node(\"generate\", generate)\nbuilder.add_edge(START, \"retrieve\")\nbuilder.add_edge(\"retrieve\", \"generate\")\nbuilder.add_edge(\"generate\", END)\n\nrag_chain = builder.compile()\n\n# Use the chain\nresult = await rag_chain.ainvoke({\"question\": \"What is the main topic?\"})\n```\n\n### Pattern 2: Custom Agent with Structured Tools\n\n```python\nfrom langchain_core.tools import StructuredTool\nfrom pydantic import BaseModel, Field\n\nclass SearchInput(BaseModel):\n    \"\"\"Input for database search.\"\"\"\n    query: str = Field(description=\"Search query\")\n    filters: dict = Field(default={}, description=\"Optional filters\")\n\nclass EmailInput(BaseModel):\n    \"\"\"Input for sending email.\"\"\"\n    recipient: str = Field(description=\"Email recipient\")\n    subject: str = Field(description=\"Email subject\")\n    content: str = Field(description=\"Email body\")\n\nasync def search_database(query: str, filters: dict = {}) -> str:\n    \"\"\"Search internal database for information.\"\"\"\n    # Your database search logic\n    return f\"Results for '{query}' with filters {filters}\"\n\nasync def send_email(recipient: str, subject: str, content: str) -> str:\n    \"\"\"Send an email to specified recipient.\"\"\"\n    # Email sending logic\n    return f\"Email sent to {recipient}\"\n\ntools = [\n    StructuredTool.from_function(\n        coroutine=search_database,\n        name=\"search_database\",\n        description=\"Search internal database\",\n        args_schema=SearchInput\n    ),\n    StructuredTool.from_function(\n        coroutine=send_email,\n        name=\"send_email\",\n        description=\"Send an email\",\n        args_schema=EmailInput\n    )\n]\n\nagent = create_react_agent(llm, tools)\n```\n\n### Pattern 3: Multi-Step Workflow with StateGraph\n\n```python\nfrom langgraph.graph import StateGraph, START, END\nfrom typing import TypedDict, Literal\n\nclass WorkflowState(TypedDict):\n    text: str\n    entities: list\n    analysis: str\n    summary: str\n    current_step: str\n\nasync def extract_entities(state: WorkflowState) -> WorkflowState:\n    \"\"\"Extract key entities from text.\"\"\"\n    prompt = f\"Extract key entities from: {state['text']}\\n\\nReturn as JSON list.\"\n    response = await llm.ainvoke(prompt)\n    return {\"entities\": response.content, \"current_step\": \"analyze\"}\n\nasync def analyze_entities(state: WorkflowState) -> WorkflowState:\n    \"\"\"Analyze extracted entities.\"\"\"\n    prompt = f\"Analyze these entities: {state['entities']}\\n\\nProvide insights.\"\n    response = await llm.ainvoke(prompt)\n    return {\"analysis\": response.content, \"current_step\": \"summarize\"}\n\nasync def generate_summary(state: WorkflowState) -> WorkflowState:\n    \"\"\"Generate final summary.\"\"\"\n    prompt = f\"\"\"Summarize:\n    Entities: {state['entities']}\n    Analysis: {state['analysis']}\n\n    Provide a concise summary.\"\"\"\n    response = await llm.ainvoke(prompt)\n    return {\"summary\": response.content, \"current_step\": \"complete\"}\n\ndef route_step(state: WorkflowState) -> Literal[\"analyze\", \"summarize\", \"end\"]:\n    \"\"\"Route to next step based on current state.\"\"\"\n    step = state.get(\"current_step\", \"extract\")\n    if step == \"analyze\":\n        return \"analyze\"\n    elif step == \"summarize\":\n        return \"summarize\"\n    return \"end\"\n\n# Build workflow\nbuilder = StateGraph(WorkflowState)\nbuilder.add_node(\"extract\", extract_entities)\nbuilder.add_node(\"analyze\", analyze_entities)\nbuilder.add_node(\"summarize\", generate_summary)\n\nbuilder.add_edge(START, \"extract\")\nbuilder.add_conditional_edges(\"extract\", route_step, {\n    \"analyze\": \"analyze\",\n    \"summarize\": \"summarize\",\n    \"end\": END\n})\nbuilder.add_conditional_edges(\"analyze\", route_step, {\n    \"summarize\": \"summarize\",\n    \"end\": END\n})\nbuilder.add_edge(\"summarize\", END)\n\nworkflow = builder.compile()\n```\n\n### Pattern 4: Multi-Agent Orchestration\n\n```python\nfrom langgraph.graph import StateGraph, START, END\nfrom langgraph.prebuilt import create_react_agent\nfrom langchain_core.messages import HumanMessage\nfrom typing import Literal\n\nclass MultiAgentState(TypedDict):\n    messages: list\n    next_agent: str\n\n# Create specialized agents\nresearcher = create_react_agent(llm, research_tools)\nwriter = create_react_agent(llm, writing_tools)\nreviewer = create_react_agent(llm, review_tools)\n\nasync def supervisor(state: MultiAgentState) -> MultiAgentState:\n    \"\"\"Route to appropriate agent based on task.\"\"\"\n    prompt = f\"\"\"Based on the conversation, which agent should handle this?\n\n    Options:\n    - researcher: For finding information\n    - writer: For creating content\n    - reviewer: For reviewing and editing\n    - FINISH: Task is complete\n\n    Messages: {state['messages']}\n\n    Respond with just the agent name.\"\"\"\n\n    response = await llm.ainvoke(prompt)\n    return {\"next_agent\": response.content.strip().lower()}\n\ndef route_to_agent(state: MultiAgentState) -> Literal[\"researcher\", \"writer\", \"reviewer\", \"end\"]:\n    \"\"\"Route based on supervisor decision.\"\"\"\n    next_agent = state.get(\"next_agent\", \"\").lower()\n    if next_agent == \"finish\":\n        return \"end\"\n    return next_agent if next_agent in [\"researcher\", \"writer\", \"reviewer\"] else \"end\"\n\n# Build multi-agent graph\nbuilder = StateGraph(MultiAgentState)\nbuilder.add_node(\"supervisor\", supervisor)\nbuilder.add_node(\"researcher\", researcher)\nbuilder.add_node(\"writer\", writer)\nbuilder.add_node(\"reviewer\", reviewer)\n\nbuilder.add_edge(START, \"supervisor\")\nbuilder.add_conditional_edges(\"supervisor\", route_to_agent, {\n    \"researcher\": \"researcher\",\n    \"writer\": \"writer\",\n    \"reviewer\": \"reviewer\",\n    \"end\": END\n})\n\n# Each agent returns to supervisor\nfor agent in [\"researcher\", \"writer\", \"reviewer\"]:\n    builder.add_edge(agent, \"supervisor\")\n\nmulti_agent = builder.compile()\n```\n\n## Memory Management\n\n### Token-Based Memory with LangGraph\n\n```python\nfrom langgraph.checkpoint.memory import MemorySaver\nfrom langgraph.prebuilt import create_react_agent\n\n# In-memory checkpointer (development)\ncheckpointer = MemorySaver()\n\n# Create agent with persistent memory\nagent = create_react_agent(llm, tools, checkpointer=checkpointer)\n\n# Each thread_id maintains separate conversation\nconfig = {\"configurable\": {\"thread_id\": \"session-abc123\"}}\n\n# Messages persist across invocations with same thread_id\nresult1 = await agent.ainvoke({\"messages\": [(\"user\", \"My name is Alice\")]}, config)\nresult2 = await agent.ainvoke({\"messages\": [(\"user\", \"What's my name?\")]}, config)\n# Agent remembers: \"Your name is Alice\"\n```\n\n### Production Memory with PostgreSQL\n\n```python\nfrom langgraph.checkpoint.postgres import PostgresSaver\n\n# Production checkpointer\ncheckpointer = PostgresSaver.from_conn_string(\n    \"postgresql:\u002F\u002Fuser:pass@localhost\u002Flanggraph\"\n)\n\nagent = create_react_agent(llm, tools, checkpointer=checkpointer)\n```\n\n### Vector Store Memory for Long-Term Context\n\n```python\nfrom langchain_community.vectorstores import Chroma\nfrom langchain_voyageai import VoyageAIEmbeddings\n\nembeddings = VoyageAIEmbeddings(model=\"voyage-3-large\")\nmemory_store = Chroma(\n    collection_name=\"conversation_memory\",\n    embedding_function=embeddings,\n    persist_directory=\".\u002Fmemory_db\"\n)\n\nasync def retrieve_relevant_memory(query: str, k: int = 5) -> list:\n    \"\"\"Retrieve relevant past conversations.\"\"\"\n    docs = await memory_store.asimilarity_search(query, k=k)\n    return [doc.page_content for doc in docs]\n\nasync def store_memory(content: str, metadata: dict = {}):\n    \"\"\"Store conversation in long-term memory.\"\"\"\n    await memory_store.aadd_texts([content], metadatas=[metadata])\n```\n\n## Callback System & LangSmith\n\n### LangSmith Tracing\n\n```python\nimport os\nfrom langchain_anthropic import ChatAnthropic\n\n# Enable LangSmith tracing\nos.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\nos.environ[\"LANGCHAIN_API_KEY\"] = \"your-api-key\"\nos.environ[\"LANGCHAIN_PROJECT\"] = \"my-project\"\n\n# All LangChain\u002FLangGraph operations are automatically traced\nllm = ChatAnthropic(model=\"claude-sonnet-4-6\")\n```\n\n### Custom Callback Handler\n\n```python\nfrom langchain_core.callbacks import BaseCallbackHandler\nfrom typing import Any, Dict, List\n\nclass CustomCallbackHandler(BaseCallbackHandler):\n    def on_llm_start(\n        self, serialized: Dict[str, Any], prompts: List[str], **kwargs\n    ) -> None:\n        print(f\"LLM started with {len(prompts)} prompts\")\n\n    def on_llm_end(self, response, **kwargs) -> None:\n        print(f\"LLM completed: {len(response.generations)} generations\")\n\n    def on_llm_error(self, error: Exception, **kwargs) -> None:\n        print(f\"LLM error: {error}\")\n\n    def on_tool_start(\n        self, serialized: Dict[str, Any], input_str: str, **kwargs\n    ) -> None:\n        print(f\"Tool started: {serialized.get('name')}\")\n\n    def on_tool_end(self, output: str, **kwargs) -> None:\n        print(f\"Tool completed: {output[:100]}...\")\n\n# Use callbacks\nresult = await agent.ainvoke(\n    {\"messages\": [(\"user\", \"query\")]},\n    config={\"callbacks\": [CustomCallbackHandler()]}\n)\n```\n\n## Streaming Responses\n\n```python\nfrom langchain_anthropic import ChatAnthropic\n\nllm = ChatAnthropic(model=\"claude-sonnet-4-6\", streaming=True)\n\n# Stream tokens\nasync for chunk in llm.astream(\"Tell me a story\"):\n    print(chunk.content, end=\"\", flush=True)\n\n# Stream agent events\nasync for event in agent.astream_events(\n    {\"messages\": [(\"user\", \"Search and summarize\")]},\n    version=\"v2\"\n):\n    if event[\"event\"] == \"on_chat_model_stream\":\n        print(event[\"data\"][\"chunk\"].content, end=\"\")\n    elif event[\"event\"] == \"on_tool_start\":\n        print(f\"\\n[Using tool: {event['name']}]\")\n```\n\n## Testing Strategies\n\n```python\nimport pytest\nfrom unittest.mock import AsyncMock, patch\n\n@pytest.mark.asyncio\nasync def test_agent_tool_selection():\n    \"\"\"Test agent selects correct tool.\"\"\"\n    with patch.object(llm, 'ainvoke') as mock_llm:\n        mock_llm.return_value = AsyncMock(content=\"Using search_database\")\n\n        result = await agent.ainvoke({\n            \"messages\": [(\"user\", \"search for documents\")]\n        })\n\n        # Verify tool was called\n        assert \"search_database\" in str(result)\n\n@pytest.mark.asyncio\nasync def test_memory_persistence():\n    \"\"\"Test memory persists across invocations.\"\"\"\n    config = {\"configurable\": {\"thread_id\": \"test-thread\"}}\n\n    # First message\n    await agent.ainvoke(\n        {\"messages\": [(\"user\", \"Remember: the code is 12345\")]},\n        config\n    )\n\n    # Second message should remember\n    result = await agent.ainvoke(\n        {\"messages\": [(\"user\", \"What was the code?\")]},\n        config\n    )\n\n    assert \"12345\" in result[\"messages\"][-1].content\n```\n\n## Performance Optimization\n\n### 1. Caching with Redis\n\n```python\nfrom langchain_community.cache import RedisCache\nfrom langchain_core.globals import set_llm_cache\nimport redis\n\nredis_client = redis.Redis.from_url(\"redis:\u002F\u002Flocalhost:6379\")\nset_llm_cache(RedisCache(redis_client))\n```\n\n### 2. Async Batch Processing\n\n```python\nimport asyncio\nfrom langchain_core.documents import Document\n\nasync def process_documents(documents: list[Document]) -> list:\n    \"\"\"Process documents in parallel.\"\"\"\n    tasks = [process_single(doc) for doc in documents]\n    return await asyncio.gather(*tasks)\n\nasync def process_single(doc: Document) -> dict:\n    \"\"\"Process a single document.\"\"\"\n    chunks = text_splitter.split_documents([doc])\n    embeddings = await embeddings_model.aembed_documents(\n        [c.page_content for c in chunks]\n    )\n    return {\"doc_id\": doc.metadata.get(\"id\"), \"embeddings\": embeddings}\n```\n\n### 3. Connection Pooling\n\n```python\nfrom langchain_pinecone import PineconeVectorStore\nfrom pinecone import Pinecone\n\n# Reuse Pinecone client\npc = Pinecone(api_key=os.environ[\"PINECONE_API_KEY\"])\nindex = pc.Index(\"my-index\")\n\n# Create vector store with existing index\nvectorstore = PineconeVectorStore(index=index, embedding=embeddings)\n```\n",{"name":5,"description":7},"main","87afe6ce96220accf50a345dea46784c8c9f210e","YYC3-Plugin-插件协议\u002FYYC3-Plugin-插件协议-plugins-claude\u002Fllm-application-dev\u002Fskills\u002Flangchain-architecture",0,"https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base","https:\u002F\u002Fkb.yyc3.top\u002F","https:\u002F\u002Fgithub.com\u002FYYC-Cube","万象归元于云枢 | 深栈智启新纪元","2026-11-10 10:37:32",{"source":8,"skillName":5,"commands":34,"prompt":44,"zipAvailable":45},[35,38,41],{"tool":36,"command":37},"npx","npx skills add YYC-Cube\u002FYYC3-Knowledge-Base --skill langchain-architecture",{"tool":39,"command":40},"bunx","bunx skills add YYC-Cube\u002FYYC3-Knowledge-Base --skill langchain-architecture",{"tool":42,"command":43},"pnpm","pnpm dlx skills add YYC-Cube\u002FYYC3-Knowledge-Base --skill langchain-architecture","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-Plugin-插件协议\u002FYYC3-Plugin-插件协议-plugins-claude\u002Fllm-application-dev\u002Fskills\u002Flangchain-architecture\u002FSKILL.md",true,[],[48,55,62,69,76,83],{"skillNo":49,"name":50,"nameZh":6,"description":51,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":52,"categories":53,"keywords":54,"publishedAt":19},"01M7CTDWHERCXPQCP0K03A86AS","vercel-sandbox","Run agent-browser + Chrome inside Vercel Sandbox microVMs for browser automation from any Vercel-deployed app. Use when the user needs browser automation in a Vercel app (Next.js, SvelteKit, Nuxt, Remix, Astro, etc.), wants to run headless Chrome without binary size limits, needs persistent browser sessions across commands, or wants ephemeral isolated browser environments. Triggers include \"Vercel Sandbox browser\", \"microVM Chrome\", \"agent-browser in sandbox\", \"browser automation on Vercel\", or any task requiring Chrome in a Vercel Sandbox.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fvercel-sandbox\u002FSKILL.md",[],[],{"skillNo":56,"name":57,"nameZh":6,"description":58,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":59,"categories":60,"keywords":61,"publishedAt":19},"01M7CTD8D2BNJY54S65M47HEJA","slack","Interact with Slack workspaces using browser automation. Use when the user needs to check unread channels, navigate Slack, send messages, extract data, find information, search conversations, or automate any Slack task. Triggers include \"check my Slack\", \"what channels have unreads\", \"send a message to\", \"search Slack for\", \"extract from Slack\", \"find who said\", or any task requiring programmatic Slack interaction.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fslack\u002FSKILL.md",[],[],{"skillNo":63,"name":64,"nameZh":6,"description":65,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":66,"categories":67,"keywords":68,"publishedAt":19},"01M7CTCSSB8ZP3Q58C3YZDZK1W","electron","Automate Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify, etc.) using agent-browser via Chrome DevTools Protocol. Use when the user needs to interact with an Electron app, automate a desktop app, connect to a running app, control a native app, or test an Electron application. Triggers include \"automate Slack app\", \"control VS Code\", \"interact with Discord app\", \"test this Electron app\", \"connect to desktop app\", or any task requiring automation of a native Electron application.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Felectron\u002FSKILL.md",[],[],{"skillNo":70,"name":71,"nameZh":6,"description":72,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":73,"categories":74,"keywords":75,"publishedAt":19},"01M7CTCBJY76688V4DCZGWFHGQ","dogfood","Systematically explore and test a web application to find bugs, UX issues, and other problems. Use when asked to \"dogfood\", \"QA\", \"exploratory test\", \"find issues\", \"bug hunt\", \"test this app\u002Fsite\u002Fplatform\", or review the quality of a web application. Produces a structured report with full reproduction evidence -- step-by-step screenshots, repro videos, and detailed repro steps for every issue -- so findings can be handed directly to the responsible teams.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fdogfood\u002FSKILL.md",[],[],{"skillNo":77,"name":78,"nameZh":6,"description":79,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":80,"categories":81,"keywords":82,"publishedAt":19},"01M7CTC4H0FFGVEAQR9PA4GA1A","agent-browser","Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to \"open a website\", \"fill out a form\", \"click a button\", \"take a screenshot\", \"scrape data from a page\", \"test this web app\", \"login to a site\", \"automate browser actions\", or any task requiring programmatic web interaction.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-WebSpec-Web标准\u002FYYC3-WebSpec-Web标准-standards\u002Fbrowser-agent\u002Fskills\u002Fagent-browser\u002FSKILL.md",[],[],{"skillNo":84,"name":85,"nameZh":6,"description":86,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":87,"categories":88,"keywords":89,"publishedAt":19},"01M7CTBKVFYBG78FDSABSDJTTQ","shadcn","Manages shadcn components and projects — adding, searching, fixing, debugging, styling, and composing UI, including chat interfaces. Provides project context, component docs, and usage examples. Applies when working with shadcn\u002Fui, component registries, presets, --preset codes, or any project with a components.json file. Also triggers for \"shadcn init\", \"create an app with --preset\", \"switch to --preset\", and for building a design system or applying a DESIGN.md or brand spec to shadcn\u002Fui.","https:\u002F\u002Fgithub.com\u002FYYC-Cube\u002FYYC3-Knowledge-Base\u002Fblob\u002Fmain\u002FYYC3-UI-界面组件\u002FYYC3-UI-界面组件-ui\u002Fskills\u002Fshadcn\u002FSKILL.md",[],[]]