playbooks

home / skills / eyadsibai / ltk / langchain-agents

langchain-agents skill

/plugins/ltk-core/skills/langchain-agents

This skill helps build and optimize LangChain agents and RAG pipelines, enabling tool use, memory, and retrieval across multiple providers.

npx playbooks add skill eyadsibai/ltk --skill langchain-agents

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
5.2 KB
---
name: langchain-agents
description: Use when "LangChain", "LLM chains", "ReAct agents", "tool calling", or asking about "RAG pipelines", "conversation memory", "document QA", "agent tools", "LangSmith"
version: 1.0.0
---

# LangChain - LLM Applications with Agents & RAG

The most popular framework for building LLM-powered applications.

## When to Use

- Building agents with tool calling and reasoning (ReAct pattern)
- Implementing RAG (retrieval-augmented generation) pipelines
- Need to swap LLM providers easily (OpenAI, Anthropic, Google)
- Creating chatbots with conversation memory
- Rapid prototyping of LLM applications

---

## Core Components

| Component | Purpose | Key Concept |
|-----------|---------|-------------|
| **Chat Models** | LLM interface | Unified API across providers |
| **Agents** | Tool use + reasoning | ReAct pattern |
| **Chains** | Sequential operations | Composable pipelines |
| **Memory** | Conversation state | Buffer, summary, vector |
| **Retrievers** | Document lookup | Vector search, hybrid |
| **Tools** | External capabilities | Functions agents can call |

---

## Agent Patterns

| Pattern | Description | Use Case |
|---------|-------------|----------|
| **ReAct** | Reason-Act-Observe loop | General tool use |
| **Plan-and-Execute** | Plan first, then execute | Complex multi-step |
| **Self-Ask** | Generate sub-questions | Research tasks |
| **Structured Chat** | JSON tool calling | API integration |

### Tool Definition

| Element | Purpose |
|---------|---------|
| **Name** | How agent refers to tool |
| **Description** | When to use (critical for selection) |
| **Parameters** | Input schema |
| **Return type** | What agent receives back |

**Key concept**: Tool descriptions are critical—the LLM uses them to decide which tool to call. Be specific about when and why to use each tool.

---

## RAG Pipeline Stages

| Stage | Purpose | Options |
|-------|---------|---------|
| **Load** | Ingest documents | Web, PDF, GitHub, DBs |
| **Split** | Chunk into pieces | Recursive, semantic |
| **Embed** | Convert to vectors | OpenAI, Cohere, local |
| **Store** | Index vectors | Chroma, FAISS, Pinecone |
| **Retrieve** | Find relevant chunks | Similarity, MMR, hybrid |
| **Generate** | Create response | LLM with context |

### Chunking Strategies

| Strategy | Best For | Typical Size |
|----------|----------|--------------|
| **Recursive** | General text | 500-1000 chars |
| **Semantic** | Coherent passages | Variable |
| **Token-based** | LLM context limits | 256-512 tokens |

### Retrieval Strategies

| Strategy | How It Works |
|----------|--------------|
| **Similarity** | Nearest neighbors by embedding |
| **MMR** | Diversity + relevance balance |
| **Hybrid** | Keyword + semantic combined |
| **Self-query** | LLM generates metadata filters |

---

## Memory Types

| Type | Stores | Best For |
|------|--------|----------|
| **Buffer** | Full conversation | Short conversations |
| **Window** | Last N messages | Medium conversations |
| **Summary** | LLM-generated summary | Long conversations |
| **Vector** | Embedded messages | Semantic recall |
| **Entity** | Extracted entities | Track facts about people/things |

**Key concept**: Buffer memory grows unbounded. Use summary or vector for long conversations to stay within context limits.

---

## Document Loaders

| Source | Loader Type |
|--------|-------------|
| **Web pages** | WebBaseLoader, AsyncChromium |
| **PDFs** | PyPDFLoader, UnstructuredPDF |
| **Code** | GitHubLoader, DirectoryLoader |
| **Databases** | SQLDatabase, Postgres |
| **APIs** | Custom loaders |

---

## Vector Stores

| Store | Type | Best For |
|-------|------|----------|
| **Chroma** | Local | Development, small datasets |
| **FAISS** | Local | Large local datasets |
| **Pinecone** | Cloud | Production, scale |
| **Weaviate** | Self-hosted/Cloud | Hybrid search |
| **Qdrant** | Self-hosted/Cloud | Filtering, metadata |

---

## LangSmith Observability

| Feature | Benefit |
|---------|---------|
| **Tracing** | See every LLM call, tool use |
| **Evaluation** | Test prompts systematically |
| **Datasets** | Store test cases |
| **Monitoring** | Track production performance |

**Key concept**: Enable LangSmith tracing early—debugging agents without observability is extremely difficult.

---

## Best Practices

| Practice | Why |
|----------|-----|
| Start simple | `create_agent()` covers most cases |
| Enable streaming | Better UX for long responses |
| Use LangSmith | Essential for debugging |
| Optimize chunk size | 500-1000 chars typically works |
| Cache embeddings | They're expensive to compute |
| Test retrieval separately | RAG quality depends on retrieval |

---

## LangChain vs LangGraph

| Aspect | LangChain | LangGraph |
|--------|-----------|-----------|
| **Best for** | Quick agents, RAG | Complex workflows |
| **Code to start** | <10 lines | ~30 lines |
| **State management** | Limited | Native |
| **Branching logic** | Basic | Advanced |
| **Human-in-loop** | Manual | Built-in |

**Key concept**: Use LangChain for straightforward agents and RAG. Use LangGraph when you need complex state machines, branching, or human checkpoints.

## Resources

- Docs: <https://docs.langchain.com>
- LangSmith: <https://smith.langchain.com>
- Templates: <https://github.com/langchain-ai/langchain/tree/master/templates>

Overview

This skill teaches how to build LLM-powered applications using LangChain patterns for agents, chains, memory, retrievers, and RAG pipelines. It focuses on practical assembly of tool-calling agents (ReAct, Plan-and-Execute), retrieval-augmented generation, and provider-agnostic model integration. The goal is fast prototyping, reliable retrieval, and observability with LangSmith.

How this skill works

The skill inspects core components: chat models (unified LLM API), agents (reason+tool invocation), chains (composable pipelines), memory modules, retrievers, and vector stores. It guides document ingestion, chunking, embedding, indexing, retrieval strategies, and final generation with context. It also covers tool definitions and LangSmith tracing for debugging and evaluation.

When to use it

  • Building agents that must call external tools or APIs using ReAct or structured tool calling
  • Implementing a RAG pipeline for question answering over documents or knowledge bases
  • Creating chatbots that require conversation memory and state management
  • Rapidly prototyping LLM applications while switching model providers
  • Needing production observability and tracing for agent behavior

Best practices

  • Start with simple helper functions or create_agent() before adding complexity
  • Make tool descriptions explicit and specific so the agent selects correctly
  • Chunk documents ~500–1000 characters for general text; test token-based sizes for tight contexts
  • Cache embeddings to reduce cost and speed up retrieval
  • Enable streaming responses for better UX and use LangSmith tracing early for debugging
  • Validate retrieval quality independently from generation to isolate errors

Example use cases

  • Customer support bot that retrieves product manuals and calls order APIs via tools
  • Internal research assistant that runs self-ask or plan-and-execute for multi-step investigation
  • Document Q&A over a mixed dataset (PDFs, web pages, code repositories) using a vector store
  • Prototype RAG demo swapping providers (OpenAI, Anthropic, local LLM) with the same code
  • Monitoring and evaluating agent behavior in production using LangSmith traces and datasets

FAQ

How do I choose chunk size for my documents?

Use 500–1000 characters as a starting point for general text; adjust down for token-limited models or up when passages must remain coherent. Validate retrieval performance after changes.

When should I use vector stores like Chroma vs Pinecone?

Use Chroma or FAISS for local development and small datasets. Move to Pinecone, Qdrant, or Weaviate for production scale, metadata filtering, or multi-region needs.