1. 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.

​

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