Chat Model Basic

​

Objectives

1. Understand the difference between using proprietary wrappers and core abstractions.
2. Develop using both approaches to see how they differ in code.
3. Adopt core abstractions for our implementations.
4. Practice invoking various provider APIs in a uniform manner.

​

Understanding the LLM Interaction API (Step-by-Step)

​

Step 1: Model Initialization (init_chat_model)

• API Call: init_chat_model("model_name", model_provider="provider")
• What it returns: It returns an initialized instance of a LangChain chat model wrapper (which inherits from the base BaseChatModel class).
• Purpose: Dynamically switches and loads the appropriate client library (such as OpenAI, Anthropic, Google GenAI, or Groq) under a single uniform interface.

​

Step 2: Model Invocation (invoke)

• API Call: model.invoke(input_data)
• What it takes: It accepts a prompt string, a list of chat message objects (like HumanMessage, SystemMessage), or a formatted PromptValue.
• What it returns: It returns an AIMessage response object from the language model.

​

Step 3: Handling the Response (AIMessage)

• What it is: An object structure that encapsulates the output generated by the assistant model.
• Key Attributes:
  • content: The raw string text returned by the model.
  • response_metadata: A dictionary holding extra metadata (such as token usage billing count, model name, and stop reason).
  • id: An optional unique identifier for the output message.

​

Step 4: Extracting the Output Text

• To read the direct text answer generated by the model (filtering out structural metadata wrappers), access the .content attribute:
  text_answer = result.content
  

​

Chat Model Basic

​

Goal

​

Sample Input

"What is 81 divided by 9?"

​

Sample Output

"81 divided by 9 is 9."

​

Plan & Code Implementation

Method 1: Using Core Abstraction Helper (Recommended)

1. Import the core abstraction helper init_chat_model from langchain.chat_models.
2. Initialize the model using init_chat_model("gpt-4o", model_provider="openai").
3. Call model.invoke() with the input string and print the response.

from dotenv import load_dotenv
from langchain.chat_models import init_chat_model

load_dotenv()

# Initialize using the core abstraction helper
model = init_chat_model("gpt-4o", model_provider="openai")

# Invoke the model
result = model.invoke("What is 81 divided by 9?")
print("Full result:")
print(result)
print("Content only:")
print(result.content)

Method 2: Using Proprietary Wrapper Class

1. Import the proprietary model wrapper ChatOpenAI from langchain_openai.
2. Initialize the model using ChatOpenAI(model="gpt-4o").
3. Call model.invoke() with the input string and print the response.

from dotenv import load_dotenv
from langchain_openai import ChatOpenAI

load_dotenv()

# Initialize using the proprietary class
model = ChatOpenAI(model="gpt-4o")

# Invoke the model
result = model.invoke("What is 81 divided by 9?")
print("Full result:")
print(result)
print("Content only:")
print(result.content)

​

Proprietary Wrappers vs. Core Abstractions

• Proprietary Wrappers: Using specific provider classes (e.g., ChatOpenAI from langchain_openai).
  • Advantages: Direct access to unique provider features and parameter optimizations.
  • Disadvantages: High code coupling; swapping providers requires refactoring imports and classes across your codebase.
  • Example:
    from langchain_openai import ChatOpenAI
    model = ChatOpenAI(model="gpt-4o")
    
• Core Abstractions: Using the unified initializer helper (init_chat_model from langchain.chat_models).
  • Advantages: Standardized interface; swap providers simply by changing parameter strings.
  • Disadvantages: Advanced provider-specific parameters must be passed indirectly via model_kwargs.
  • Example:
    from langchain.chat_models import init_chat_model
    model = init_chat_model("gpt-4o", model_provider="openai")
    

[!IMPORTANT] To ensure maximum flexibility and avoid having to remember different SDK endpoints, imports, and API conventions, we will adopt Core Abstractions (init_chat_model) throughout this module to practice invoking various provider APIs in a uniform manner.

​

Shifting Providers Seamlessly (Gemini and Groq)

1. Shifting to Google Gemini

from dotenv import load_dotenv
from langchain.chat_models import init_chat_model

load_dotenv()

# Simply change the parameters using core abstractions
model = init_chat_model("gemini-2.5-flash", model_provider="google_genai")

result = model.invoke("What is 81 divided by 9?")
print(result.content)

2. Shifting to Groq

from dotenv import load_dotenv
from langchain.chat_models import init_chat_model

load_dotenv()

# Simply change the parameters using core abstractions
model = init_chat_model("llama-3.3-70b-versatile", model_provider="groq")

result = model.invoke("What is 81 divided by 9?")
print(result.content)

​

Exercise: Capital City Agent 🏗

​

Goal

​

Sample Input

"What is the capital of India?"

​

Sample Output

"The capital of India is New Delhi."

​

Plan

1. Use init_chat_model to load the OpenAI model.
2. Invoke the model with a string querying the capital of India.
3. Print the result content.

from langchain.chat_models import init_chat_model
from dotenv import load_dotenv

load_dotenv()
model = init_chat_model("gpt-4o", model_provider="openai")
res = model.invoke("What is the capital of India?")
print(res.content)

​

Practice & Exercises