Integrations, sandboxes, and deployment stack
LangChain integrations with model providers, databases, web tools, Redis, E2B, Coinbase AgentKit, React UIs, local models, and infrastructure for deploying agents.
42.5%
Best tweets about LangChain
40 Best Tweets About LangChain (2026)
Discover the best tweets about LangChain, including agents, retrieval, tools, structured output, evaluations, integrations, and production development.
Specific LangChain components, releases, architectures, integrations, debugging, evaluations, limitations, and production experience.
- Creators
- 32
- Updated
Original Xholic analysis
What 40 top LangChain posts reveal
LangChain discussion is concentrated in agent harnesses and context control, integrations and deployment, and RAG architecture. Posts highlight practical components such as state, sandboxes, retrieval pipelines, tracing, and UI approval controls, while some authors argue that framework abstractions may not fit highly customized production systems.
- Dominant tone
- Positive
- Median score
- 11.8
- Leading format
- Announcement
- Recent posts
- 40%
67.5% of posts
All-time engagement
55% of posts
Published in 90 days
Conversation map
The themes creators return to
Agent harnesses and context control
Deep Agents and other harness designs for planning, tools, filesystem/shell access, subagents, context compaction, memory, middleware, and long-running coding agents.
40%
RAG and retrieval architecture
LangChain retrieval pipelines, chunking and preprocessing, embeddings, vector stores, GraphRAG, hybrid retrieval, query transformations, and grounded documentation assistants.
30%
LangGraph orchestration and durable workflows
Graph-based agent control flow, stateful orchestration, checkpoints, human interrupts, retries, and production execution with systems such as Temporal.
25%
Framework tradeoffs and ecosystem positioning
Comparisons with LangGraph, CrewAI, direct APIs, and alternatives; critiques of framework abstractions, provider lock-in, production suitability, and ecosystem adoption.
22.5%
Product releases, docs, and learning resources
New LangChain and LangSmith capabilities, open-source repositories, courses, notebooks, documentation experiences, and implementation walkthroughs.
22.5%
Observability, debugging, and evaluation
Tracing agent and RAG behavior, diagnosing failures, evaluator workflows, hallucination detection, experiment inspection, and continuous production improvement via LangSmith and related tools.
15%
Agent safety and governance
Permission gates, PII handling, compliance logic, sandboxing, human approval, architecture constraints, and governance of shared agent memory.
10%
Tone and stance
Sentiment Positive leads
Author posture Supportive leads
Performance benchmark
- Median likes
- 33
- Median reposts
- 7
- Median replies
- 5
- Median views
- 4.8K
Posts with media make up 70% of this collection. Their median all-time score is 14.3, compared with 4.70 for text-only posts.
Format mix
- Announcement 55% · score 10.3
- Tutorial 25% · score 17.1
- Opinion 10% · score 7.45
- Case Study 5% · score 5964.8
Consensus and debate
Where creators agree, and where they do not
Shared view
Harness design is a recurring production concern
Posts emphasize planning, context management, permissions, tool access, recovery, and isolated subagents as important parts of an agent system beyond the model call itself.
Shared view
RAG discussion extends beyond embeddings
Posts discuss retrieval pipelines, source-grounded indexing, preprocessing and metadata, and graph-oriented data modeling as RAG design considerations.
Shared view
Observability is presented as an iteration tool
Tracing, document-relevance scoring, evaluator reasoning, and experiment comparison are presented as ways to investigate agent and RAG failures.
Shared view
Integrations span application and infrastructure layers
Examples connect LangChain or LangGraph with Coinbase AgentKit, pgvector, Redis, E2B sandboxes, React UI tooling, and Temporal-based execution stacks.
Open debate
Frameworks versus direct APIs
One tooling map describes LangChain as a fast path to a working agent, while other posts argue that direct APIs and infrastructure may be a better fit when systems require custom ontologies, domain schemas, or other specialized constraints.
Open debate
Managed convenience versus control
Posts announce sandboxed and managed-agent capabilities, while one author raises concerns about single-provider dependence and responsibility to end users.
What performs
Patterns behind standout posts
Case studies had the highest format median
Case studies had the highest median all-time score among formats at 5964.8. The Coinbase AgentKit and LangChain voice-agent example was the largest overall outlier, with an all-time score of 11759.57.
Agent-harness content had a strong theme median
The agent-harnesses and context-control theme had a median all-time score of 22.42. Its evidence includes posts on a Claude Code harness analysis, LangChain Deep Agents, and graph-based agent design.
Tutorial median exceeded announcement median
Tutorials recorded a 17.09 median all-time score, compared with 10.32 for announcements. Analytics classifies the free-agent repository, image-embedding notebook, and middleware post as tutorial examples.
Posts with media had a higher median score
Media appeared in 28 of 40 posts (70%). Posts with media had a 14.26 median all-time score, versus 4.7 for text-only posts.
Statistical standouts
- View standout post 1 Score 11759.6 · 992.37× median
- View standout post 2 Score 1164.5 · 98.27× median
- View standout post 3 Score 303.5 · 25.61× median
- View standout post 4 Score 188.4 · 15.9× median
- View standout post 5 Score 188.2 · 15.88× median
Creator landscape
Who shapes this conversation
The five most represented creators account for 25% of the selected posts.
-
1. Vaishnavi
@_vmlops
2 posts
-
2. divyansh tiwari
@DivyanshT91162
2 posts
-
3. Afiz ⚡️
@itsafiz
2 posts
-
4. LangChain
@LangChain
2 posts
-
5. LangChain JS
@LangChain_JS
2 posts
-
6. Paul Iusztin
@pauliusztin_
2 posts
Santiago's posts pair implementation examples with system architecture
Santiago’s two posts feature an image-anomaly notebook using LangChain, OpenCLIP, and Oracle vector storage, plus a source-code walkthrough for an airline-policy RAG assistant using LangChain, LangGraph, pgvector, and Terraform.
Official LangChain accounts highlight developer-facing product surfaces
Official LangChain and LangChain JS posts cover grounded documentation chat, LangSmith experiment inspection, human approval interrupts in UI flows, and React UI integrations.
Since the previous snapshot
What changed since Aug 12, 2026
- 57.5% of the selected posts remained.
- The creator count changed by +6.
- The leading sentiment remained stable.
How this analysis was made
Themes, sentiment, stance, and post format are classified per tweet. All counts, shares, medians, creator concentration, freshness, and performance comparisons are then calculated directly from the published snapshot.
Xholic's all-time score compares engagement while accounting for reach, post age, and creator consistency. It is used for relative comparisons within this collection.
This report analyzes the exact 40-post snapshot shown below. AI identifies editorial categories and drafts explanations; all statistics are calculated from the snapshot, and every narrative claim is checked against cited posts before publication.
Best LangChain tweets
Top LangChain tweets from 32 creators
Ranked 01–40
- 01
@dtelecom ·
We’re now featured in the @CoinbaseDev AgentKit ecosystem. dTelecom is listed among the providers supporting the next generation of AI agents with onchain capabilities. To show what that looks like in practice, we built a Voice Agent example using: - Coinbase AgentKit - a LangChain ReAct agent - dTelecom’s decentralized voice infra Users can speak commands like: “Check my USDC balance” “Send 1 USDC to 0x…” The agent interprets the request, chooses the right onchain tool, executes the action, and speaks the result back. Read more below ↓
- 02
@akshay_pachaar ·
Claude Code fully dissected! Researchers from UCL reverse-engineered the leaked Claude source. What they found changes how you should think about agent design. Only 1.6% of the codebase is AI decision logic. The other 98.4% is operational infrastructure. Permission gates, tool routing, context compaction, recovery logic, session persistence. The model reasons. The harness does everything else. This is the opposite of what most agent frameworks do today. LangGraph routes model outputs through explicit state machines. Devin bolts heavy planners onto operational scaffolding. Claude Code gives the model maximum decision latitude inside a rich deterministic harness, and invests all its engineering effort in that harness. The core loop is a simple while-true. Call model, run tools, repeat. But the systems around that loop are where the real design lives: A permission system with 7 modes and an ML classifier. Users approve 93% of prompts anyway, so the architecture compensates with automated layers instead of adding more warnings. A 5-layer context compaction pipeline. Each layer runs only when cheaper ones fail. Budget reduction, snip, microcompact, context collapse, auto-compact. Four extension mechanisms ordered by context cost. Hooks (zero), skills (low), plugins (medium), MCP (high). Each answers a different integration problem. Subagents return only summary text to the parent. Their full transcripts live in sidechain files. Agent teams still cost roughly 7x the tokens of a standard session. Resume does not restore session-scoped permissions. Trust is re-established every session. That friction is the point. The bet behind all of this is simple. As frontier models converge on raw coding ability, the quality of the harness becomes the differentiator, not the model. Paper: Dive into Claude Code (arXiv:2604.14228) In the next tweet, I've shared an article I wrote on Agent Harness and what every big company is building. Do check.
- 03
@techNmak ·
Our RAG system is 90% accurate. Sounds great until you realize: that 10% is destroying user trust. Here's what's happening: 9 out of 10 queries: Perfect answers. Users love it. 1 out of 10 queries: Complete hallucination. Users lose confidence. The trust problem with LLMs: > Users don't know which answers to trust. > One hallucination makes them question everything, even the correct answers. It's like a doctor who's right 90% of the time. Would you trust them? Why 90% isn't good enough: In traditional software: > 90% uptime is terrible > 99.9% is standard > 99.99% is expected In LLM applications: > Many teams are at 80-90% accuracy > Think that's acceptable > Don't realize it's killing adoption What's causing the 10%: After debugging, we found: 40% = Retrieval returned irrelevant documents 30% = LLM ignored good documents and hallucinated 20% = Documents were relevant but contradictory 10% = Prompt was ambiguous You can only see this with proper observability. We implemented Opik (open-source LLM observability): > Traces every retrieval > Scores document relevance > Flags hallucinations automatically > Shows when LLM ignores context > Catches bad outputs before users see them. Built by Comet. Works with LangGraph, LangChain, etc. Self-hostable or cloud. Check the next tweet for GitHub Repo:
- 04
@itsafiz ·
LangChain just open-sourced Deep Agents—an agent harness that’s opinionated and ready-to-run out of the box. Instead of wiring up prompts, tools, and context management yourself, you get a working agent immediately and customize what you need. It’s an MIT-licensed system that’s perfect for anyone trying to understand how high-end coding agents are structured. @LangChain What’s inside the harness: - Planning: write_todos for task breakdown and progress tracking. - Filesystem: Full context control via read_file, write_file, edit_file, ls, glob, and grep. - Shell Access: execute for running commands (with sandboxing). - Sub-agents: task tool for delegating work with isolated context windows. - Smart Defaults: Optimized prompts that teach the model how to use these tools effectively. - Context Management: Auto-summarization for long threads and large outputs saved directly to files. Link in the comments
- 05
@svpino ·
Here is a killer way to use embeddings: I built a notebook to show you how to do anomaly detection on images. Anomaly detection is one of the most common problems in the real world. Learn how to implement anomaly detection, and you'll be able to solve a ton of use cases that happen every day: • Predicting equipment failures • Identifying defective products • Identifying tumors in medical images • Spotting counterfeit products • Detecting fraud • Flagging fake reviews • Detecting bot traffic My notebook focuses on images. It uses: • Langchain • OpenClip embeddings • Oracle vector store This is the way my example works: • You start with a collection of similar images • You can then check whether a new image "belongs" to that collection I generate embeddings and use Oracle 26ai to store them and retrieve similar images on demand.
Watch video
- 06
@svpino ·
We should build a church for people who open-source their code so everyone can learn from it. Here is the complete source code of a RAG assistant to navigate airline policies. You get the complete source code and video from @lenadroid, walking you through everything she did (I'm linking to the video in the first comment below). The fact that you can watch every engineering decision that Lena made when building this app is pure gold. A few things you'll pick up from this: • It uses LangChain for the retrieval pipeline • It uses LangGraph for conversation state • It stores embeddings in Postgres with pgvector • It indexes documents to ground answers in the source text • It uses Terraform to stand up the infrastructure I'm linking to the video walkthrough and the source code below.
- 07
@_avichawla ·
There's a new RAG approach that: - cuts corpus size by 40x. - reduces tokens per query by 3x. - improves vector search relevance by 2.3x. And it delivered 260% accuracy improvement on medical RAG benchmark over standard RAG. Here's the core problem this new approach solves: Chunks in a standard RAG pipeline typically carry no info about version, clearance level, or source authority. The embedding model encodes it the same way regardless of whether the chunk is an outdated draft or the latest approved version. During retrieval, if an outdated chunk and a latest chunk get retrieved as context, the LLM has no signal to prefer one over the other. So it combines both and hallucinates. The issue is not retrieval but rather the representation. The unit itself is wrong, and the fix has to happen before retrieval, at the data layer. Blockify is an open-source data preprocessing engine that solves this at the data layer. The engine sits between the document parser and the vector store. Here's how it works: - First, a context-aware splitter finds natural breaks (paragraph boundaries, section breaks, topic shifts). - Instead of embedding raw segments directly, a purpose-built LLM processes each one and extracts structured knowledge units called IdeaBlocks (typically 2-3 sentences). Each unit isolates a different fact or concept. - Each unit is paired with a contextualized question and answer. This mirrors how users query the system and ensures the query embedding sits closer to real queries in the vector space (HyDE does something similar). - Each block also carries metadata info like entity name, entity type, version, and clearance level. This helps rank retrieval by recency and authority, not just similarity. The pipeline runs in two stages. - The Ingest model converts raw text into IdeaBlocks as described above. - The Distill model then clusters semantically similar blocks across the full set and merges duplicates into one canonical unit before indexing. The retrieved units now answer a specific question instead of returning a paragraph that might contain the answer somewhere in the middle. On the published benchmarks: - The pipeline reduces a corpus to roughly 2.5% of its original size while preserving 99% factual integrity. - Token consumption per query drops by 3x, from 1.5k tokens (naive top-5 chunks) to 500 tokens (top-5 IdeaBlocks). - Vector search relevance improves 2.3x, measured by cosine distance. In medical evaluation, the same pipeline delivered up to 650% accuracy improvement on clinical-grade RAG with a quantized Llama 3.2 3B model running on-device. The Blockify engine composes with LangChain and LlamaIndex. You can swap out the chunking stage (NodeParser/TextSplitter) and produce IdeaBlock nodes that the rest of the pipeline consumes normally. For storage, you can integrate it directly with most vector DBs like Milvus, Elastic, etc. There is also a Claude Code skill in the repo that runs the full Ingest and Distill pipeline while referencing the project documentation. For production workloads on Intel Xeon, an optimized build is available through OpenVINO. I've shared the GitHub repo in the replies.
Watch video
- 08
@VaibhavSisinty ·
There's a quiet shift happening in how AI agents are built. And if you missed it, you'll be confused by everything that comes next. For the last year, AI agents worked in loops. You give it a task. It plans. It acts. It checks. It fixes. It goes again. One cycle, repeating until done. Claude Code, Codex, Cursor all of them work this way. Plan, act, observe, repeat. In June, two things happened that gave this pattern a name. Peter Steinberger from the AI engineering community wrote: "You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents." Boris Cherny, head of Claude Code at Anthropic, said the same thing differently: "I don't write the prompt anymore. Claude writes the prompt, and now I'm talking to that new Claude that is coordinating." That was the loop engineering era. It lasted about a month. Now Steinberger posted nine words that blew up: "Are we still talking loops or did we shift to graphs yet?" Here's the difference. A loop is one agent going in circles. Plan, act, check, repeat. It works for simple tasks. But give it something complex and it starts spinning burning tokens, optimizing the wrong thing, or gaming its own success metric without actually solving the problem. A graph is multiple agents connected in a network. One agent writes code. A separate agent reviews it without seeing the first agent's reasoning. A third agent tries to break what was built. A fourth checks whether the original task was even understood correctly. Each one is still running a loop. But they're connected watching each other, feeding each other, vetoing each other. LangGraph already models this. It treats an agent as a graph where boxes do work and arrows decide what runs next. Those arrows can point backward, which is what makes loops possible inside the graph. JetBrains calls it graph-based orchestration the most deterministic approach for production systems. O'Reilly's 2026 AI Agents Stack puts it as the foundational layer. The real-world version is already running. Klarna uses graph-based agent systems for customer service. Kimi K3's Agent Swarm decomposes tasks into parallel sub-agents that coordinate simultaneously. Anthropic's own Boris Cherny mapped out five stages of AI adoption and Stage 4 is exactly this: thousands of agents running in a graph, kicked off by other agents, with humans steering by intent. Andrew Ng wrote about it in his June Batch letter. When Andrew Ng names a pattern, it usually means the pattern has already won. The reason this matters right now: agents are getting autonomous. Running for hours. Thousands of tool calls. Spawning sub-agents. One loop can't keep that trustworthy. You need loops watching loops. That's the graph. The skill that mattered last year was writing better prompts. The skill that matters this year is designing the system that writes the prompts, checks the work, and knows when to stop.
- 09
- 10
@DivyanshT91162 ·
BUILD A REAL AI AGENT FOR $0 WITH THIS GITHUB REPO. No paid APIs. No monthly subscription. No credit card. Everything you need is free: • LangChain + LangGraph to build the agent • Groq or Gemini Free Tier as the LLM • DuckDuckGo for free web search • Memory with LangGraph checkpoints • Automatic Groq → Gemini fallback if one provider fails • Runs locally on your laptop • MIT licensed and fully open source By the end, you'll have an AI agent that can: → Reason through tasks → Use tools automatically → Search the web → Remember conversations → Recover from provider outages → Run completely free This is one of the best beginner-friendly AI agent repositories I've seen. Repo: https://t.co/elikLqLyNi
Watch video
- 11
- 12
- 13
@fahdmirza ·
💥 DeerFlow 2.0 + Ollama is HERE 🦌 ♠ ByteDance just dropped an open-source Super Agent Harness that can do almost anything 🚀 🔹 Orchestrates sub-agents, memory & sandboxes in one harness 🔹 Runs on your own GPU with Ollama — fully local & private 🔹 Extensible skills system — teach it new workflows with a Markdown file 🔹 Built on LangGraph & LangChain with Docker sandbox execution 🔹 Hit #1 on GitHub Trending with 39k+ stars in weeks 🔥 Full install walkthrough + live demo below 👇
- 14
- 15
@Voxyz_ai ·
same claude, same gpt. one person ships a million lines in 5 months, another can't keep it running for 2 hours. the difference isn't the model. it's everything around it. they call it harness engineering. three things decide the outcome: evaluation loops (agents can't grade their own work), architecture constraints (rules enforced by linters, not by hoping the agent listens), and memory governance (one agent's hallucination can't pollute every other agent through shared knowledge). one example: langchain ran an experiment. same model, only changed the harness. pass rate jumped from 52.8% to 66.5%. vercel deleted 80% of their agent's tools and got better results. same chef, different kitchen management. food quality goes up a level. the chef didn't change. the menu didn't change. what changed is who tastes the food, who watches the process, and who remembers which dish got sent back three times last week. try one thing tonight: give your agent a task, then have a completely different model review its output. not letting it check itself. you'll immediately see what it missed. that's the smallest version of an evaluation loop. do it once and you'll understand why the harness matters more than the model.
- 16
@sukh_saroy ·
🚨LangChain open sourced a complete RAG course - 18 notebooks, a full YouTube playlist, and implementations of every major RAG technique from the research papers. It's called RAG From Scratch. And it's not a tutorial blog post. It's a structured set of Jupyter notebooks that implement each RAG technique from first principles, paired with 5-10 minute videos explaining the papers they're based on - built by the team that maintains LangChain. Here's what's covered: → Basics -- indexing, retrieval, and generation from scratch → Query Translation -- multi-query, RAG-Fusion, decomposition, step-back, HyDE → Routing -- logical and semantic routing to direct queries to the right datasource → Query Structuring -- LLM converts natural language to SQL, Cypher, or other DSLs → Multi-Representation Indexing -- embed summaries for retrieval, return full docs for generation → RAPTOR -- recursively summarize and cluster documents for multi-level retrieval → ColBERT -- contextual token-level embeddings for higher retrieval granularity → Adaptive-RAG -- dynamically routes queries by complexity to different RAG approaches → Corrective-RAG -- self-corrects retrieval errors with in-loop relevance tests and web search fallback → Self-RAG -- grades retrieved documents and generated answers for hallucinations and quality Here's the wildest part: Every technique is implemented from scratch in a notebook, not just explained. Each notebook has a matching video that traces through the paper it's based on. Fine-tuning is expensive and bad at factual recall. RAG is how you actually give an LLM knowledge it doesn't have. This is the complete curriculum. 6K GitHub stars. 1.6K forks. Built by LangChain. 100% Open Source. (Link in the comments)
- 17
@hasantoxr ·
I'm replacing OpenAI, Cohere, and AWS Comprehend with one open-source server. It's called SIE. One docker run gets you 85+ models behind three API calls: → encode() for embeddings (Stella, BGE-M3, SPLADE) → score() for reranking (BGE-reranker v2) → extract() for named entity recognition (GLiNER, Florence-2) The cost difference is brutal. AWS Comprehend entity extraction → $5,000/month Same workload on a spot A10G with SIE → $5/month That's the same models, your own cloud, and a 1000x cheaper bill. It ships the full production stack out of the box: → OpenAI-compatible /v1/embeddings (swap the base URL and you're done) → KEDA autoscaling on Kubernetes → Terraform modules for GKE and EKS → Grafana dashboards → All 85+ models quality-verified against MTEB in CI Native integrations with LangChain, LlamaIndex, Haystack, DSPy, CrewAI, Chroma, Qdrant, and Weaviate. Your data never leaves your VPC. Apache 2.0. Built by Superlinked.
- 18
@Redisinc ·
Agents are shipping everywhere with @LangChain and Redis. Those that survive production aren't just prompting better—they’re engineering better context. The problem? “Context engineering” gets tossed around like it’s obvious. It’s not. It’s a skill you build. That’s why we launched our free “Context Engineering with Redis & LangChain” lab on Redis University. You’ll build a course advisor agent step-by-step, layering system context, RAG that actually improves answers, persistent memory, and user intent—using Redis for vector search and agent memory, all orchestrated with LangChain. If context engineering has felt like a buzzword, this makes it real. Get started on Redis University: https://t.co/pJmkBkuarh
- 19
@NVIDIAAIDev ·
👀 @LangChain is leveling up agentic workflows Victor Moreira, a LangChain engineer, breaks down 2 essential tools for improving performance and reliability with @llm_wizard. ✅Deep Agent Harness to manage complex, long-duration tasks and boost LLM performance. ✅LangSmith for tracing agents in production and allowing for continuous improvement. Catch more interviews from our #NVIDIAGTC developer livestream: https://t.co/bTR5XeQ2xz
Watch video
- 20
@LangChain ·
Chat LangChain is now embedded directly in our docs 📚 You can ask questions grounded in: • Full docs (LangSmith + OSS) • Knowledge base • OSS code We’ve been investing heavily in developer experience. This is one step toward making everything easier and more accessible. Try it out 👉 https://t.co/FdTB9DpTkl
- 21
@LangChain ·
The hardest part of debugging an AI agent isn't knowing it failed--it's knowing why. We rebuilt the detail view in LangSmith Experiments from the ground up to answer that question faster. Next time you click and inspect any experiment results, you will find: * Less clutter * Better trace visibility * Clearer evaluator reasoning * Easier comparison workflows. Try it out at https://t.co/NZbDhzp8xX and let us know what you think!
Watch video
- 22
@Hartdrawss ·
Sneak peek from a $10,000+ product we’re building right now ! Simply, infrastructure that lets teams deploy & manage agents in production with proper observability, and cost management For the core, we’re using : - LangGraph for stateful agent orchestration - Temporal .io for durable, reliable execution - LiteLLM for smart model routing and cost control - FastAPI + react for the backend and dashboard Still early, but the direction feels right. What do y'all think ? 👀
- 23
@LangChain_JS ·
Human-in-the-loop in @LangChain UIs is a clean pattern: the agent interrupts, your frontend reads the pending action, and the user decides whether to approve, reject, or edit before execution continues. Interrupts show up as regular stream state, so rendering a review UI feels like standard app code, not a special workflow engine. 🧵👇
Watch video
- 24
@ujjwalscript ·
Do you know WHY your Developer Resume goes to TRASH inspite adding AI projects? Every junior developer in 2026 thinks the only way to get an interview is to build a new "AI Chatbot" Here is a brutal truth from the hiring side: They are ignoring your AI wrappers. When your GitHub is full of LangChain boilerplate and API calls to Claude, it doesn't prove you are a modern developer. It proves you know how to copy-paste the same tutorial as 50,000 other applicants. It shows absolutely zero ability to handle state, database concurrency, or actual user logic. Want to stand out? Build something incredibly, painfully boring. Instead of a "Generative UI Bot," build a sports venue booking app that actually lets local schools reserve physical grounds. Why? Because a booking app is a nightmare of real-world logic. You have to handle timezone discrepancies, prevent concurrent double-bookings, manage role-based access for school admins, and integrate actual payment gateways. An AI API wrapper just requires a credit card and an API key. A physical-world booking system requires an Engineer. Stop trying to out-AI the AI on your resume. We don't need more people who can write prompts. We need people who understand how to translate messy, physical-world problems into clean, scalable architecture.
- 25
@itsafiz ·
This is huge! LangChain is launching LangSmith Sandboxes, which makes easy to write and execute code in agents. @LangChain Now in private preview. Find the details 👇
Watch video
- 26
@LangChain_JS ·
We just shipped new docs showing how to wire @langchain/react's #useStream hook to any React UI library 🎉 Two ready-to-go integrations: 🧩 AI Elements: composable, @shadcn - ui-style components for chat 🤖 @assistantui: headless runtime with a full thread UI out of the box 📚 https://t.co/UnJq2HBkT6
- 27
- 28
@DivyanshT91162 ·
What if I told you the most-starred AI agent framework might not be the best one? This new research analyzed the health of 15 major open-source AI agent frameworks over 3+ years using: • 808,042 GitHub stars • 73,997 pull requests • 86,241 commits • 987,330 GitHub profiles The findings challenge one of the biggest assumptions in open source. Here are the highlights: • AutoGPT gained 111K+ stars in a single month, but converted fewer than 9 contributors per 1,000 stars. • Pydantic-AI had far fewer stars, yet a much stronger contributor density—showing deeper real-world adoption. • LangChain attracted 82.5% of developers who contributed across multiple AI agent frameworks, making it the ecosystem's shared infrastructure. • The biggest contributor drop happens within the first 30 days. Projects that retain contributors beyond 90 days build much healthier communities. The authors argue that GitHub stars are a popularity metric—not an ecosystem metric. Instead, they recommend evaluating projects based on: • Contributor density • Cross-ecosystem engagement • Long-term contributor retention This is one of the most insightful studies on the AI agent ecosystem I've seen. It changes how we should evaluate open-source projects. Paper link👇
- 29
@pauliusztin_ ·
There are 3 ways to model your ontologies for GraphRAG: (And your decision can make or break your system) So I assessed the tradeoffs while designing the ontology + data model for an OpenClaw-style assistant on @MongoDB Here’s what I found: 1/ Append-only log + materialized view (evolving ontology) Two collections: Log: {log_id, type: "Person", name: "Paul", attr: {"role": "founder"}} Graph: aggregated node per entity/edge Pros: • Full ontology versioning over time • Replayability and auditability of extracted knowledge • Flexible snapshots (2023 vs 2025) for analytics Cons: • Duplicate data + indexes • Vector + text indexes competing for RAM (~2–4x) • Costly aggregation cycles Powerful… but expensive to scale. 2/ One collection (ontology embedded in nodes) Edges inside nodes (LangChain’s default @MongoDB GraphRAG). Example: {_id: "person:Paul", out: [{to: "task:write", type: "TODO"}]} Pros: • Fewer documents • Simple ontology + data model mapping Cons: • Duplicated relationships • 1 edge update → 2 docs • Fragile writes, hard rollbacks • Hard to query relationships directly Works on a small scale… But breaks as your ontology grows. 3/ One collection (ontology as nodes + edges) Edges become first-class docs: Node: {_id: "person:Paul"} Edge: {source: "person:Paul", type: "TODO", target: "task:write"} Pros: • Explicit, enforceable ontology • Edges are queryable + updatable • No duplication • Simpler writes + recovery • Native $graphLookup support • Works natively with $graphLookup Cons: •No temporal history Most practical for production GraphRAG. @MongoDB makes implementing ontology-driven knowledge graphs in a single system straightforward: • $graphLookup → graph traversal in one query (no JOIN recursion hell) • Built-in vector + text search alongside graph queries • Easy horizontal scaling via sharding (AWS/GCP, multi-region) Takeaway: GraphRAG looks like a retrieval problem. It’s an ontology + data modeling problem first. Because your schema defines: • Performance • Cost (especially RAM) • Reliability • Retrieval quality P.S. What data model are you using (or would you use) for your Knowledge Graph?
- 30
@daytonaio ·
At the recent @daytonaio Compute Conference, @hwchase17, co-founder & CEO of @LangChain in conversation with our CEO @ivanburazin broke down why agent harnesses are replacing frameworks as the core primitive, and why memory is still the biggest unsolved problem in agentic AI.
Watch video
- 31
@codestirring ·
Shipped v1.2.0 of the Phoenix SaaS Starter Kit today 🛠️ - Upgraded to Elixir 1.20 and bumped every dependency - Replaced LangChain with ReqLLM - Fixed a security issue in the blog renderer - Cleaned up warnings across the multi-tenancy, and payments generators https://t.co/UoLEcf1g2u #MyElixirStatus
- 32
@michael_chomsky ·
This is one of the things I dislike about managed agents. Is it the best DX? yes. Is it now much, much more usable because it's bring your own sandbox? yes (most startups now have Sandbox credits and want to use them). But if something like this happens, I'm responsible to my users, not Anthropic. I think limiting yourself to one LLM provider is a bad idea at this point. YC startups also can't use it because they have 2M to spend on OAI and the lock-in is too strong. If you're building agents, look at LangChain DeepAgents. It's the best platform that looks better than anything I have seen so far, but managed DeepAgents are still behind a waitlist so I have. been unable to test.
- 33
@pauliusztin_ ·
"Should I use LangGraph or CrewAI for my custom AI agent?" I get asked this at least 3x a week... My answer is always the same: None. Use the APIs directly. Right now, I'm building a unified memory layer for my AI agents. • @MongoDB for unified memory • @PrefectIO for durable workflows • Opik by @Cometml for observability • Direct LLM APIs • Python In 2 days, I had a working GraphRAG-style system. I actually tried frameworks first. But that's where things broke. The moment you need: • Custom ontology constraints • Immutable observation logs • Hybrid search fusion • Composite IDs • Domain-specific schemas • Multi-hop graph traversal You start fighting the framework. This is because AI frameworks encode assumptions. And your production system rarely matches those assumptions. Infrastructure tools support your logic. AI frameworks replace it. @MongoDB solves storage, search, and graph traversal. @PrefectIO solves orchestration and retries. Opik by @Cometml solves observability. LLM APIs solve reasoning. These are the hard problems. Your domain logic should stay yours. Here's the gist: Frameworks are great when you don’t know what to build. But once the system design is clear, from-scratch is often faster. Especially now with coding agents... They don’t struggle with writing Python. But they do struggle fighting abstractions. P.S. Are you using AI frameworks or writing from scratch?
- 34
@neo4j ·
In this guide, you'll see which tools are useful to build the context you need to avoid hallucinations on your #llms - including orchestration (@LangChain and @llama_index) the memory layer, and tool integration (MCP) Context is key. Start building it with this useful guide. 🚀 https://t.co/sL894Uxrko
- 35
- 36
@AndrewK404 ·
a map of the AI-agent tooling zoo every framework grouped by what it's actually for SERVING vLLM - default OSS serving engine SGLang - best for high-throughput serving TensorRT-LLM - best for NVIDIA inference Ollama - simplest local models LM Studio - best local GUI, especially Apple Silicon llama.cpp - local ecosystem core note: HF's TGI - legacy; GATEWAY / ROUTER LiteLLM - default self-hosted gateway OpenRouter - hosted marketplace Portkey - production governance Cloudflare AI Gateway - best if you're already on CF note: OpenAI-compatible endpoints are table stakes now → moat moved to governance + cost AGENT FRAMEWORKS LangGraph - default serious agent runtime LangChain - fastest path to a working agent DeepAgents - batteries-included LangGraph harness OpenAI Agents SDK - lightweight primitives Google ADK - Gemini / Vertex-native Pydantic AI - best type-safe Python feel Mastra - best TS-native framework Agno - fast multi-agent runtime smolagents - code-as-action minimalist agent Strands Agents - AWS model-driven agents Microsoft Agent Framework - legacy Core merger CrewAI - fastest role-based multi-agent prototype LlamaIndex / Haystack - best for RAG-first agents PROMPT OPTIMIZATION DSPy - program, don't prompt OPEN ERSONAL-AGENT RUNTIMES OpenClaw - local-first personal assistant runtime Hermes - self-improving autonomous agent runtime OpenHands - self-hosted autonomous coding agent OpenCode - best OSS terminal alternative note: this is where personal agents live + orchestration frameworks VECTOR DB / RETRIEVAL Pinecone - managed default Qdrant - best Rust engine Weaviate - best native hybrid Milvus - scale champion Chroma - prototyping default pgvector - best if you're already on Postgres LanceDB - embedded multimodal lakehouse Turbopuffer - cheapest cold vector + FTS MEMORY Mem0 - drop-in memory layer Zep + Graphiti - temporal knowledge graph Letta - self-editing agent memory Cognee - self-hosted graph + vector memory TRACING / OBSERVABILITY LangSmith - default for LangChain / LangGraph Langfuse - best OSS self-hosted Arize Phoenix - best free dev-time tracing Helicone - easiest proxy-style logging Traceloop / OpenLLMetry - OpenTelemetry for LLMs W&B Weave - W&B-native tracing + eval Comet Opik - fast-growing OSS option Pydantic Logfire - SQL-queryable traces EVALS Promptfoo - best YAML evals + red-teaming DeepEval - pytest for LLMs Ragas - default RAG metrics TruLens - feedback-function evals Inspect - safety-grade evals OpenAI Evals - legacy Braintrust - enterprise all-in-one lm-eval-harness / HELM - base-model benchmarks PROMPT MANAGEMENT PromptLayer - prompt CMS Latitude - OSS prompt platform Agenta - OSS prompt + eval + observability LangSmith Prompt Hub - git-like prompt versioning GUARDRAILS / SAFETY Guardrails AI - composable validators NeMo Guardrails - programmable conversation rails Llama Guard - open-weights safety classifier Lakera - real-time LLM firewall
- 37
- 38
@TeksCreate ·
Firecrawl just crossed 152K stars on GitHub. If you're building AI agents that need web data, this is the scraper everyone's using. What it does: one API that handles search, scraping, and web interaction at scale. You give it a URL, it returns clean markdown. You give it a search query, it crawls and extracts. For AI agents, this replaces the brittle soup of BeautifulSoup + requests + manual parsing. Why it matters for agent builders: - HTML-to-markdown conversion that actually preserves structure (tables, lists, code blocks) - JS rendering for SPAs and dynamic content - LLM-ready output — no cleaning step needed before feeding context to your model - Self-hostable (AGPL) or cloud API The 152K stars aren't hype. Every AI agent framework worth using this year — LangChain, CrewAI, AutoGen — integrates Firecrawl as their default web tool. It's become the standard layer between agents and the messy web. If your agent can't browse the web reliably, it's not an agent. It's a chatbot with delusions. https://t.co/hHGvxebkqo
- 39
- 40
@_vmlops ·
LANGCHAIN LETS YOU CHAIN LLMS TOGETHER TO BUILD ACTUAL APPS, NOT JUST PROMPTS Harrison Chase started the project in october 2022, right before chatgpt blew up the space. the framework is now one of the most used ways to build around LLMs the core idea → components you can snap together: ▪️ prompt templates: reusable structures for different question styles ▪️ LLMs: plug in GPT-3, BLOOM, or hugging face models ▪️ agents: let the model decide what tool to use next (search, calculators, etc) ▪️ memory: short-term and long-term context across a conversation the pinecone handbook walks through the basics: writing your first prompt template, running it through a hugging face model, then swapping in an OpenAI model to compare output quality good starting point if you're building your first LLM app and want to understand the pieces before jumping into agents https://t.co/J0wBgkLunv
Best Tweets by Topic