LangChain development for LLM applications and agents

LangChain is a framework for building agents and LLM applications. It gives you one interface to many model providers, plus tools, retrieval and middleware. LangGraph adds stateful, multi-step workflows with pauses for human review, and LangSmith traces and evaluates what the agent did. We build with all three, and we tell you when a direct API call would be simpler.
LangChain
  • Agents that call your own tools and data
  • Retrieval over your documents with a vector store
  • Stateful, multi-step workflows with LangGraph
  • Tracing and evaluation with LangSmith

When LangChain is the right choice

LangChain suits LLM features that are more than a single prompt:

  • You want to switch or compare model providers without rewriting your application logic. LangChain's standard model interface covers many providers.
  • Your agent calls several tools, such as database lookups or your own APIs, and the model decides which one to use.
  • You need retrieval over your own documents, with loaders, text splitters, embeddings and a vector store that can each be swapped.
  • The workflow runs over many steps, must resume after a failure or must pause for a person to approve an action. LangGraph's persistence and human-in-the-loop support are built for that.

When LangChain is not the right choice

A framework adds layers. Skip it when they do not pay for themselves:

  • You make one model call with one prompt. The provider's own SDK is simpler, with fewer dependencies to keep up to date.
  • Your pipeline is fixed and never lets the model choose a step. Plain code is easier to read, test and debug.
  • You depend on one provider's newest or most specific features. Check that the LangChain integration exposes them, or call that provider directly for those parts.
  • You only need LangGraph's orchestration. LangGraph's documentation says you do not need LangChain to use it.

What we build with LangChain

Typical projects, described in general terms.

Agents with tools

Agents that call your functions and APIs, with tool descriptions the model can understand and errors it can recover from.

Retrieval over your content

Question answering over documents, with chunking, embeddings and a vector store, using fixed or agent-driven retrieval.

Multi-step workflows

LangGraph workflows that mix fixed steps with model-driven steps and resume where they left off.

Human approval

Tool calls that pause for a person to approve, edit or reject before anything runs.

Model and provider choice

One code path for hosted models and locally run models, so you can compare or switch providers.

Tracing and evaluation

LangSmith traces of every run, and test datasets built from real conversations to catch regressions.

What LangChain, LangGraph and LangSmith each do

LangChain's core agent API, create_agent, takes a model, a list of tools and a system prompt, and runs the model loop. Middleware adds behavior step by step, such as guardrails, retries and custom tool policies. Models are named with a provider prefix, so swapping one provider for another needs little code change, and the same interface covers structured output and streaming. For retrieval, LangChain provides document loaders, text splitters, embedding models, vector stores and retrievers. Its documentation describes three patterns: two-step RAG, where retrieval always runs first; agentic RAG, where the agent decides when to search; and hybrid designs that add validation steps.

LangGraph is a lower-level orchestration framework and runtime for long-running, stateful agents. LangChain agents are built on it. LangSmith is a platform for tracing, debugging and evaluating agents, and it works with other frameworks too.

In our own work, we built a retrieval prototype with LangChain and a locally run model through Ollama. It sat inside a back end for a multi-provider AI chat assistant, with Qdrant as the vector store.

What a production LLM application needs beyond the framework

  • Persistent memory: conversation memory needs a checkpointer and a thread ID. The in-memory checkpointer loses everything on restart, so production uses a database-backed one, such as Postgres. Checkpoints build up over long conversations, so plan a retention policy.
  • Context limits: a full history may not fit the model's context window, and long contexts can lower quality and raise cost. We trim or summarize older messages before each model call.
  • Tool errors: LangChain handles tool errors in middleware. We retry where that is safe and return error messages the model can act on.
  • Human review: the human-in-the-loop middleware pauses chosen tool calls until a person decides. It needs a persistent checkpointer so the run can resume.
  • Streaming: agents can stream step-by-step progress, model tokens and custom progress messages from tools, so users are not left waiting.
  • Long-term memory: facts and preferences that should outlast one conversation go in a store, not in thread state.
  • Evaluation: LangSmith runs offline experiments on datasets during development and online evaluators on live traffic. Failing production traces become new test cases.

How we work

  1. Check that you need a framework: if one model call does the job, we say so and build it directly
  2. Build the smallest working agent: one model, the tools it really needs and tracing switched on from the start
  3. Add state and review where they matter: persistent memory, human approval for actions with side effects, and streaming for long tasks
  4. Test and hand over: an evaluation dataset, a record of which model and provider each part uses, and notes on reading a trace

Frequently asked questions

Do we need LangChain to build an AI agent?

No. For a single model call or a fixed pipeline, the provider's own SDK is often simpler. LangChain earns its place when you use several tools, retrieval, more than one provider, or memory across turns.

What is the difference between LangChain and LangGraph?

LangChain's create_agent is a configurable agent harness built on LangGraph. LangGraph is the lower-level orchestration layer for long-running, stateful workflows that mix fixed steps with model-driven steps, and it can be used without LangChain.

Can we run the model on our own hardware?

Yes. LangChain's documentation names Ollama as one of the easiest ways to run chat and embedding models locally, which suits privacy-sensitive work. The same code can switch to a hosted model later.

How do we know the agent is working well?

LangSmith records traces of each run, including tool calls and latency. Offline evaluations score versions against a dataset before release, and online evaluations score live traffic. Failures from production can be added to the dataset.

How can we work together?

There are three ways, on the same terms:

  • Dedicated team, best for ongoing work: interview the developers, then they work on your project full or part time.
  • Fixed scope, best when requirements are clear: we agree the scope and the price up front, and deliver against it.
  • Time and material, best when the scope will change: you pay for the time used and can change priorities as the work goes on.

Whichever you choose, we sign an NDA before work starts, you own the code we write, and every change is reviewed in your repository.

Can I interview the developers before we start?

Yes. For a dedicated team you meet the developers in an online call and interview them before they join your project.

Building an agent or an AI assistant?

Tell us what it should do, which data it needs and which models you are considering. We will say whether LangChain fits or whether a direct API call is enough.

Tell us about your project

Tell us what you need built, fixed or improved. We come back with questions, a suggested approach and an estimate.