# How to Use gpt4free with LangChain: Complete Integration Guide

> Integrate gpt4free with LangChain using the ChatAI class. This guide shows how to connect to free LLM providers easily and unlock powerful AI applications. Get started now.

- Repository: [Tekky/gpt4free](https://github.com/xtekky/gpt4free)
- Tags: how-to-guide
- Published: 2026-03-04

---

**Yes, gpt4free provides a native LangChain integration via the `ChatAI` class, which inherits from `langchain_community.chat_models.openai.ChatOpenAI` and routes all requests through the g4f client to free LLM providers.**

The gpt4free LangChain integration allows you to swap expensive API calls with free provider alternatives while keeping your existing LangChain chains, agents, and streaming logic intact. The integration lives in the `g4f.integration.langchain` module and handles message conversion, provider selection, and async execution automatically.

## How the gpt4free LangChain Integration Works

### Core Components

The integration consists of three primary components that bridge LangChain's abstraction layer with gpt4free's provider ecosystem:

| Component | File Path | Purpose |
|-----------|-----------|---------|
| **ChatAI** | [`g4f/integration/langchain.py`](https://github.com/xtekky/gpt4free/blob/main/g4f/integration/langchain.py) | LangChain-compatible chat model that wraps g4f clients |
| **Client / AsyncClient** | [`g4f/client/__init__.py`](https://github.com/xtekky/gpt4free/blob/main/g4f/client/__init__.py) | Handles provider routing, retries, and response formatting |
| **ChatCompletionMessage** | [`g4f/client/stubs.py`](https://github.com/xtekky/gpt4free/blob/main/g4f/client/stubs.py) | Pydantic model that translates LangChain messages to OpenAI-compatible format |

### Message Flow Architecture

When you invoke a LangChain chain using `ChatAI`, the following sequence occurs:

1. **Validation**: The `validate_environment` method in `ChatAI` extracts `provider` from `model_kwargs` and instantiates both `g4f.Client` and `g4f.AsyncClient`.

2. **Conversion**: LangChain `BaseMessage` objects are converted to `ChatCompletionMessage` stubs using a monkey-patched `openai.convert_message_to_dict` function defined in [`g4f/integration/langchain.py`](https://github.com/xtekky/gpt4free/blob/main/g4f/integration/langchain.py).

3. **Execution**: The g4f client selects the specified provider (e.g., Gemini, Claude, Perplexity) and handles the HTTP request, retries, and error handling.

4. **Response**: The provider response is wrapped in a LangChain `AIMessage` and returned to your chain.

## Setting Up gpt4free with LangChain

### Installation

Ensure you have both packages installed:

```bash
pip install g4f langchain langchain-community

```

### Basic Synchronous Usage

Import `ChatAI` from the integration module and specify your desired provider via `model_kwargs`:

```python
from g4f.integration.langchain import ChatAI
from langchain.schema import HumanMessage

# Initialize with any free provider supported by g4f

chat = ChatAI(
    model="gpt-4o",  # Placeholder for logging; actual model determined by provider

    model_kwargs={"provider": "Gemini"}  # Select Gemini, Claude, Perplexity, etc.

)

response = chat.invoke([HumanMessage(content="Explain quantum computing in one sentence.")])
print(response.content)

```

The `model` parameter is used only for identification; the actual LLM serving the request is determined by the `provider` value.

## Advanced gpt4free LangChain Patterns

### Streaming Responses

The integration supports LangChain's streaming interface, yielding tokens as they arrive from the provider:

```python
from g4f.integration.langchain import ChatAI
from langchain.schema import HumanMessage

chat = ChatAI(
    model="gpt-4o",
    model_kwargs={"provider": "Claude"}
)

# Stream tokens in real-time

for chunk in chat.stream([HumanMessage(content="Write a haiku about Python programming.")]):
    print(chunk.content, end="", flush=True)

```

### Building LLM Chains

Use `ChatAI` within standard LangChain chains and prompt templates:

```python
from g4f.integration.langchain import ChatAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

template = """You are an expert coding assistant.
User: {question}
Assistant:"""
prompt = PromptTemplate.from_template(template)

llm = ChatAI(
    model="gpt-4o",
    model_kwargs={"provider": "Perplexity"}
)

chain = LLMChain(llm=llm, prompt=prompt)
result = chain.run({"question": "What is the difference between a list and a tuple in Python?"})
print(result)

```

### Async Execution

For high-concurrency applications, the integration automatically creates an `AsyncClient` instance accessible via `agenerate` and `astream`:

```python
import asyncio
from g4f.integration.langchain import ChatAI
from langchain.schema import HumanMessage

async def main():
    chat = ChatAI(
        model="gpt-4o",
        model_kwargs={"provider": "DeepInfra"}
    )
    
    response = await chat.agenerate([
        [HumanMessage(content="Summarize the theory of relativity in 50 words.")]
    ])
    print(response.generations[0][0].text)

asyncio.run(main())

```

## Key Implementation Files

Understanding the source structure helps with debugging and extending the integration:

| File | Description | Link |
|------|-------------|------|
| [`g4f/integration/langchain.py`](https://github.com/xtekky/gpt4free/blob/main/g4f/integration/langchain.py) | Contains `ChatAI` class, environment validation, and message conversion logic. | [View on GitHub](https://github.com/xtekky/gpt4free/blob/main/g4f/integration/langchain.py) |
| [`g4f/client/__init__.py`](https://github.com/xtekky/gpt4free/blob/main/g4f/client/__init__.py) | Implements `Client` and `AsyncClient` classes that manage provider selection and request execution. | [View on GitHub](https://github.com/xtekky/gpt4free/blob/main/g4f/client/__init__.py) |
| [`g4f/client/stubs.py`](https://github.com/xtekky/gpt4free/blob/main/g4f/client/stubs.py) | Defines Pydantic models like `ChatCompletionMessage` that bridge g4f responses with LangChain expectations. | [View on GitHub](https://github.com/xtekky/gpt4free/blob/main/g4f/client/stubs.py) |
| `g4f/Provider/` | Directory containing individual provider implementations (e.g., [`Gemini.py`](https://github.com/xtekky/gpt4free/blob/main/Gemini.py), [`Claude.py`](https://github.com/xtekky/gpt4free/blob/main/Claude.py)). | [View on GitHub](https://github.com/xtekky/gpt4free/tree/main/g4f/providers) |

## Summary

- **gpt4free LangChain integration** is available via `g4f.integration.langchain.ChatAI`, which inherits from LangChain's `ChatOpenAI` class.
- The integration routes all requests through **g4f.Client** or **AsyncClient**, enabling access to dozens of free providers by specifying `model_kwargs={"provider": "ProviderName"}`.
- **Message conversion** is handled automatically via monkey-patched OpenAI utilities in [`g4f/integration/langchain.py`](https://github.com/xtekky/gpt4free/blob/main/g4f/integration/langchain.py), ensuring compatibility with LangChain chains, agents, and streaming interfaces.
- Both **synchronous** and **asynchronous** execution patterns are supported, making the integration suitable for production web applications and batch processing pipelines.

## Frequently Asked Questions

### Can I use any gpt4free provider with LangChain?

Yes. The `ChatAI` class accepts any provider name available in the g4f ecosystem through the `model_kwargs={"provider": "ProviderName"}` parameter. This includes providers like Gemini, Claude, Perplexity, and DeepInfra. If a provider supports the OpenAI-compatible chat completion interface, it will work seamlessly with LangChain chains.

### Does gpt4free LangChain integration support streaming?

Yes. The integration implements LangChain's standard `stream` method, yielding `ChatCompletionChunk` objects as tokens arrive from the provider. You can use the same streaming patterns you would use with OpenAI's official LangChain integration, making it a drop-in replacement for real-time text generation applications.

### Is the gpt4free LangChain wrapper compatible with async operations?

Yes. The `ChatAI` class automatically instantiates both synchronous (`Client`) and asynchronous (`AsyncClient`) g4f clients during initialization. You can use `agenerate` and `astream` methods for non-blocking execution, which is essential for high-concurrency applications built with FastAPI, asyncio, or similar async frameworks.

### How do I handle authentication for providers that require API keys?

You can pass API keys through the standard `api_key` parameter when initializing `ChatAI`, or include them in `model_kwargs`. During the `validate_environment` method, the integration extracts these values and passes them to the underlying `g4f.Client`. This allows you to use providers that require authentication while maintaining the same LangChain interface.