LangChain Models | Indepth Tutorial with Code Demo | Video 3 | CampusX

LangChain’s “Models” component is built to give one common interface for working with different AI model providers—so code can switch between language and embedding models without rewriting everything. The core idea is that LangChain standardizes how applications talk to models that otherwise behave differently across companies. In practice, LangChain supports two model types: language models (for text in → text out) and embedding models (for text in → vectors out). Language models power chatbots and other text-generation features, while embedding models convert text into numeric vectors that enable semantic search—an essential ingredient for RAG-style systems that answer questions using relevant documents.

The tutorial then drills into the practical differences between LLMs and chat models, because LangChain treats them as distinct categories even though both return text. LLMs are general-purpose models suited for tasks like summarization, translation, question answering, and code generation; they typically take a single prompt string and return a single text string. Chat models are specialized for conversation: they accept sequences of messages (multi-turn context) and are better aligned with building assistants, customer-support bots, and coding helpers. A key operational takeaway is that modern LangChain workflows increasingly favor chat models, while LLM support is described as less recommended for newer projects.

After establishing the conceptual split, the walkthrough moves into code demos that show how to call multiple providers through LangChain with a consistent pattern. For language models, it demonstrates OpenAI’s GPT 3.5 Turbo Instruct via LangChain’s OpenAI integration, then repeats the same flow using chat models with GPT 4. It also shows how outputs differ: chat model responses include structured metadata (tokens, completion details), so developers may need to extract the actual answer from fields like “content.” The tutorial further compares provider options by switching to Anthropic’s Claude 3.5 and Google’s Gemini 1.5 Pro, again using LangChain’s chat model interface.

Two generation controls get special attention: temperature and max completion tokens. Temperature is framed as a creativity/determinism dial—lower values yield more predictable outputs (useful for coding or factual tasks), while higher values increase randomness (useful for brainstorming, stories, and poems). Max completion tokens limits how much text the model can produce, which matters because API pricing is token-based.

The tutorial then tackles open-source models, explaining why they’re attractive: they can be downloaded and run locally (reducing dependency on paid APIs and improving control over data), but they require stronger hardware and can be less refined due to different training/fine-tuning approaches. Using Hugging Face, it demonstrates both API-based access (via Hugging Face Inference) and local execution. A small model, TinyLlama (1.1B parameters), is used to keep the demo feasible, and the local run highlights real-world constraints like slow downloads and heavy memory/compute demands.

Finally, the focus shifts to embedding models. It shows how to generate embeddings with OpenAI (including vector dimensionality choices) and how to generate embeddings locally with Hugging Face using Sentence Transformers—specifically all-MiniLM-L6-v2. The closing demo builds a simple document similarity system: it embeds a set of documents and a user query, computes cosine similarity between vectors, sorts by similarity score while preserving document indices, and returns the most relevant document. The workflow is positioned as the foundation for RAG: embeddings enable retrieval, and retrieval is what grounds answers in the most relevant text.