DEV Community: Gate of AI

Build AI with Claude Sonnet 4.6 & LangChain

Gate of AI — Sat, 06 Jun 2026 11:56:16 +0000

🚀 Technical Briefing: This tutorial is part of our deep-dive series on Agentic Workflows at Gate of AI. For the full technical breakdown, interactive code sandbox, and the native Arabic translation, visit the original article here.

<span>Tutorial</span>
<span>Intermediate</span>
<span>⏱ 45 min read</span>
<span>© Gate of AI 2026-06-06</span>

Learn to build a conversational AI application using Claude Sonnet 4.6 and LangChain, leveraging the latest AI advancements for dynamic interactions.

Prerequisites

Python 3.10 or newer
Claude Sonnet 4.6 API key
Intermediate programming skills

What We're Building

In this tutorial, we will construct a conversational AI application using the Claude Sonnet 4.6 model from Anthropic, integrated with LangChain to handle complex dialogues and maintain conversational context. The application will be capable of understanding user input, managing context over long interactions, and providing intelligent responses. Notably, Claude Sonnet 4.6 features a 1M token context window, enhancing its ability to manage extensive conversations.

The finished project will allow users to interact with the AI in a conversational manner, enabling capabilities such as answering questions, providing recommendations, and even executing specific tasks based on user queries. This project demonstrates the power of combining state-of-the-art language models with robust conversational frameworks.

Setup and Installation

To get started, we'll set up our development environment by installing necessary libraries and configuring our environment variables. This setup ensures that we have all tools required to build and run our application.

pip install langchain anthropic

Next, configure your environment variables to securely store your Claude Sonnet 4.6 API key. This key is essential for authenticating your requests to the Anthropic API.



  
  
  .env file


CLAUDE_API_KEY=your_claude_sonnet_4_6_api_key_here

Step 1: Initialize the LangChain Framework

LangChain provides a powerful framework for managing conversation flows and maintaining context. In this step, we initialize LangChain and set up the basic configuration for our conversational AI.



from langchain import LangChain

from anthropic import Anthropic

  
  
  Initialize LangChain


lc = LangChain()

  
  
  Configure LangChain with Claude Sonnet 4.6


client = Anthropic(api_key='your_claude_sonnet_4_6_api_key_here')

lc.add_model('claude-sonnet-4-6', client)

Here, we import the necessary libraries and initialize LangChain. We then configure it to use the Claude Sonnet 4.6 model by providing our API client. This setup is crucial for integrating the language model into our conversation framework.

Step 2: Define Conversation Logic

In this step, we define the logic that will drive our conversation. This involves setting up handlers for different types of user input and configuring how the AI should respond.



def handle_greeting(input_text):

    return "Hello! How can I assist you today?"

def handle_farewell(input_text):

    return "Goodbye! Have a great day!"

def default_handler(input_text):

    # Use Claude Sonnet 4.6 for intelligent responses

    response = client.messages.create(

        model="claude-sonnet-4-6",

        messages=[{"role": "user", "content": input_text}]

    )

    return response.get('content', 'I am sorry, I am unable to process that.')

  
  
  Register handlers


lc.register_handler("greeting", handle_greeting)

lc.register_handler("farewell", handle_farewell)

lc.default_handler = default_handler

In this code block, we define functions to handle greetings and farewells, and a default handler that leverages the Claude Sonnet 4.6 model for more complex interactions. These handlers are registered with LangChain, allowing it to route user inputs to the appropriate logic.

Step 3: Implementing the Interaction Loop

Finally, we implement the main interaction loop that will continuously accept user input and provide responses, creating a seamless conversational experience.



def run_conversation():

    print("Welcome to the AI chat! Type 'exit' to end the session.")

    while True:

        user_input = input("You: ")

        if user_input.lower() == 'exit':

            print("AI: Goodbye!")

            break

        response = lc.handle_message(user_input)

        print(f"AI: {response}")

  
  
  Start the conversation


run_conversation()

This loop continuously prompts the user for input, processes it through LangChain, and prints out the AI's response. The loop will terminate when the user types 'exit', providing a clean and user-friendly interaction.

⚠️ Common Mistake: Ensure your API keys are correctly configured in the environment variables. Failing to do so will result in authentication errors when trying to access the Claude API.

Testing Your Implementation

To verify that your conversational AI is working correctly, initiate the interaction loop and test various inputs. You should expect intelligent and contextually appropriate responses from the AI.



  
  
  Test the conversation by running the script


python your_script_name.py

During testing, ensure that the AI can handle various types of input and maintains context across interactions. This will validate the effectiveness of your LangChain setup and the integration with Claude Sonnet 4.6.

What to Build Next

Integrate voice input and output to create a voice-enabled assistant.
Expand your AI's capabilities by adding more specialized handlers for specific tasks.
Deploy your application as a web service using frameworks like FastAPI or Flask.

Consider how such applications can be integrated into regional initiatives like Saudi Vision 2030 or the UAE's National Strategy for AI, enhancing local technological infrastructure and capabilities.

Build a Conversational AI with LlamaIndex

Gate of AI — Thu, 04 Jun 2026 15:22:31 +0000

🚀 Technical Briefing: This tutorial is part of our deep-dive series on Agentic Workflows at Gate of AI. For the full technical breakdown, interactive code sandbox, and the native Arabic translation, visit the original article here.

<span>Tutorial</span>
<span>Intermediate</span>
<span>⏱ 20 min read</span>
<span>© Gate of AI 2026-06-04</span>

Learn to build an intelligent conversational AI agent by leveraging LlamaIndex to dynamically orchestrate and route prompts between OpenAI and Anthropic APIs.

Prerequisites

Python 3.10 or newer
API keys for OpenAI and Anthropic
Intermediate knowledge of Python and asynchronous programming

What We're Building

In this tutorial, we will construct an agentic conversational AI companion using LlamaIndex. Instead of using primitive hardcoded logic to route user intent, we will use a ReAct (Reasoning and Acting) agent loop. This workflow allows the core engine to evaluate a user's prompt and dynamically choose whether to delegate the task to OpenAI's GPT-4o or Anthropic's Claude 3.5 Sonnet.

Setup and Installation

Modern versions of LlamaIndex are modular. We must install the core framework alongside the specific multi-model provider integration packages.

pip install llama-index llama-index-llms-openai llama-index-llms-anthropic python-dotenv

Next, configure your environment variables securely. Create a .env file in your root project directory:



  
  
  .env file


OPENAI_API_KEY=your_openai_api_key

ANTHROPIC_API_KEY=your_anthropic_api_key

Step 1: Initializing LLMs with LlamaIndex Abstractions

First, we configure our environment and initialize our language models using the official LlamaIndex wrappers. This standardizes their inputs and outputs.



import os

import asyncio

from dotenv import load_dotenv

from llama_index.llms.openai import OpenAI

from llama_index.llms.anthropic import Anthropic

load_dotenv()

  
  
  Instantiate the respective LLM configurations


gpt_model = OpenAI(model="gpt-4o")

claude_model = Anthropic(model="claude-3-5-sonnet-20241022")

Step 2: Defining Functional Agent Tools

To let our agent interact with these models dynamically, we wrap the model invocations inside LlamaIndex FunctionTool structures. The docstrings act as the prompt-hints the agent reads to make its structural decisions.



from llama_index.core.tools import FunctionTool

def call_gpt_engine(prompt: str) -> str:

    """Useful when queries require raw logic, structured JSON formatting, or math calculations."""

    response = gpt_model.complete(prompt)

    return str(response)

def call_claude_engine(prompt: str) -> str:

    """Useful when queries require deeply creative writing, code generation, or nuanced tonal analysis."""

    response = claude_model.complete(prompt)

    return str(response)

  
  
  Convert functions to native tools


gpt_tool = FunctionTool.from_defaults(fn=call_gpt_engine)

claude_tool = FunctionTool.from_defaults(fn=call_claude_engine)

Step 3: Creating the ReAct Agent

Now, we construct the ReActAgent, passing our custom model tools directly into its execution layout. We will use GPT-4o as our central engine coordinator.



from llama_index.core.agent import ReActAgent

  
  
  Bind tools to the orchestration framework


tools = [gpt_tool, claude_tool]

agent = ReActAgent.from_tools(tools, llm=gpt_model, verbose=True)

⚠️ Architecture Reminder: Ensure you are using separate packages like llama-index-llms-openai. Importing directly from a legacy global namespace will result in structural ModuleNotFoundError crashes.

Testing Your Implementation

Execute queries targeting different tasks to see LlamaIndex evaluate the text, pick a tool, format its variables, and cleanly handle responses.



async def main():

    # This should trigger the Claude tool based on your docstring hints

    creative_res = await agent.achat("Write a short, moody poem about artificial intelligence.")

    print(f"Creative Task:\n{creative_res}\n")

# This should route to the GPT tool
structured_res = await agent.achat("Generate a structured list of 3 fake user profiles with keys: id, name.")
print(f"Structured Task:\n{structured_res}\n")



if name == "main":

    asyncio.run(main())

What to Build Next

Add a VectorStoreIndex to supply localized RAG context windows straight to your tool execution pathways.
Incorporate persistent database storage to preserve chat histories across multiple app sessions.
Expose your LlamaIndex orchestration wrapper via a robust FastAPI framework backend.

Build a RAG System with OpenAI & Pinecone

Gate of AI — Thu, 04 Jun 2026 15:15:35 +0000

> 🚀 Technical Briefing: This tutorial is part of our deep-dive series on Agentic Workflows at Gate of AI. For the full technical breakdown, interactive code sandbox, and the native Arabic translation, visit the original article here.

Building a Modern Retrieval-Augmented Generation (RAG) System with OpenAI and Pinecone

Learn how to build a state-of-the-art Retrieval-Augmented Generation (RAG) system using OpenAI's GPT models and Pinecone for efficient information retrieval and generation. This tutorial will guide you through setting up a system that combines the power of language models with vector databases to retrieve relevant information and generate contextually rich responses, incorporating the latest advancements in RAG technology.

Prerequisites

Python 3.10 or above
OpenAI API key
Pinecone account and API key
Intermediate knowledge of Python and RESTful APIs

What We're Building

In this tutorial, you'll learn how to build a Retrieval-Augmented Generation (RAG) system. This system combines the power of OpenAI's language models with Pinecone's vector database to retrieve relevant information and generate contextually rich responses. The RAG system is designed to handle unstructured data and provide accurate, detailed answers by leveraging both retrieval and generation capabilities. By the end of this tutorial, you will have a fully functional RAG system that can be used in various applications, such as customer support, knowledge management, and more. The system will retrieve relevant documents from a vector database and use a language model to generate coherent and informative responses.

Setup and Installation

We will begin by setting up our development environment. This involves installing the necessary Python packages and configuring environment variables for API access.

pip install openai pinecone

Next, we need to configure our environment variables. Create a file named .env in your project directory and add the following variables:

OPENAI_API_KEY=your_openai_api_key
PINECONE_API_KEY=your_pinecone_api_key
PINECONE_ENVIRONMENT=your_pinecone_environment

These environment variables will allow our application to authenticate with the OpenAI and Pinecone APIs securely.

Step 1: Data Preparation and Indexing

The first step is to prepare our dataset and index it using Pinecone. We will break our dataset into chunks, compute vector embeddings, and store them in a Pinecone index for efficient retrieval.

import os
from openai import OpenAI
from pinecone import Pinecone

# Load API keys from environment variables
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
pc = Pinecone(api_key=os.getenv("PINECONE_API_KEY"), environment=os.getenv("PINECONE_ENVIRONMENT"))

# Create a Pinecone index
index_name = "document-index"
index = pc.Index(name=index_name, dimension=1536, metric="cosine")

# Example dataset
documents = ["Document 1 content...", "Document 2 content...", "Document 3 content..."]

# Function to create vector embeddings
def create_embeddings(text):
    response = client.embeddings.create(model="text-embedding-ada-002", input=text)
    return response['data'][0]['embedding']

# Index documents
for i, doc in enumerate(documents):
    embedding = create_embeddings(doc)
    index.upsert([(f"doc_{i}", embedding)])

In this step, we initialize the Pinecone client and create an index with a specified dimension and metric. We then generate embeddings for each document using OpenAI's embedding model and upload them to the Pinecone index.

Step 2: Implementing the Retrieval Function

Next, we implement a function to query the Pinecone index and retrieve documents that are semantically similar to the input query.

def retrieve_documents(query, top_k=3):
    # Generate query embedding
    query_embedding = create_embeddings(query)
    
    # Query Pinecone index
    results = index.query(query_embedding, top_k=top_k, include_values=True)
    
    # Extract document IDs
    document_ids = [match['id'] for match in results['matches']]
    return document_ids

# Example query
query = "Explain the concept of RAG systems."
retrieved_docs = retrieve_documents(query)
print("Retrieved document IDs:", retrieved_docs)

This function takes a query string, generates its embedding, and performs a similarity search in the Pinecone index. The top K matching document IDs are returned, representing the most relevant documents to the query.

Step 3: Generating Responses with OpenAI

With the relevant documents retrieved, we can now use OpenAI's GPT model to generate a response. This involves constructing a prompt that includes the retrieved documents and the user query.

def generate_response(query, document_ids):
    # Retrieve document contents
    documents_content = [documents[int(doc_id.split("_")[1])] for doc_id in document_ids]
    
    # Construct prompt
    prompt = f"Given the following documents:\n\n{'\n\n'.join(documents_content)}\n\nAnswer the following question:\n{query}"
    
    # Generate response using OpenAI GPT
    response = client.completions.create(
        model="gpt-4o",
        prompt=prompt,
        max_tokens=200
    )
    return response.choices[0].text.strip()

# Generate a response
response = generate_response(query, retrieved_docs)
print("Generated Response:", response)

We retrieve the content of the documents using their IDs, then construct a prompt for the GPT model. The model generates a response based on the combined information from the documents and the query.

Testing Your Implementation

To verify that our RAG system works correctly, we will test it with various queries and check that the responses are both relevant and informative.

# Test with different queries
test_queries = [
    "What is the purpose of retrieval-augmented generation?",
    "How does Pinecone help in information retrieval?",
    "Explain how GPT models generate text."
]

for test_query in test_queries:
    retrieved_docs = retrieve_documents(test_query)
    response = generate_response(test_query, retrieved_docs)
    print(f"Query: {test_query}\nResponse: {response}\n")

Run these test queries to ensure that the system retrieves the correct documents and generates accurate responses. Adjust the prompt or retrieval parameters if necessary based on the output quality.

What to Build Next

Enhance the retrieval function to use a hybrid approach combining semantic and keyword search for improved accuracy.
Integrate a user interface for real-time interaction with the RAG system, allowing users to input queries and receive responses directly.
Expand the dataset and explore different domain-specific applications, such as medical information retrieval or legal document analysis.

Consider integrating this technology with regional initiatives like Saudi Vision 2030 to enhance AI-driven solutions in the GCC region, leveraging the latest advancements in Dynamic and Parametric RAG for more adaptive and efficient information retrieval systems.

Building an Advanced LangChain AI Workflow Automation with LangGraph

Gate of AI — Wed, 03 Jun 2026 16:24:19 +0000

🚀 Technical Briefing: This tutorial is part of our deep-dive series on Agentic Workflows at Gate of AI. For the full technical breakdown, interactive code sandbox, and the native Arabic translation, visit the original article here.

<span>Tutorial</span>
<span>Advanced</span>
<span>⏱ 45 min read</span>
<span>© Gate of AI 2026-06-03</span>

Build a production-grade multi-agent workflow using LangGraph v1.2. Use state-based orchestration to manage autonomous reasoning loops securely.

Prerequisites

Python 3.10+
LangChain v1.3.4+ and LangGraph v1.2.4+
OpenAI API Key (GPT-4o)
Understanding of Pydantic and TypedDict for state management

Installation

pip install langchain==1.3.4 langgraph==1.2.4 langchain-openai

Step 1: Define the State Schema

In modern agentic workflows, "Memory" is replaced by an explicit State Schema. This allows the graph to pass data between nodes with type safety.

from typing import TypedDict, Annotated

import operator

from langchain_core.messages import BaseMessage

class AgentState(TypedDict):

  # Annotate as 'list' to append new messages instead of overwriting

  messages: Annotated[list[BaseMessage], operator.add]

  task_goal: str

  generated_topology: str

Step 2: Orchestrate with LangGraph

We replace the legacy Agent class with Nodes and Edges. This allows for "Time-Travel Debugging" and human-in-the-loop checkpoints.

from langgraph.graph import StateGraph, END

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o", temperature=0.2)

  
  
  Define Node Logic


def understand_task(state: AgentState):

  # ... logic to parse natural language ...

  return {"task_goal": "Optimized Ethylene Cracking"}

def generate_topology(state: AgentState):

  # ... logic to output process structure ...

  return {"generated_topology": "C2H4 -> C2H2 + H2"}

  
  
  Build the Graph


workflow = StateGraph(AgentState)

workflow.add_node("understand", understand_task)

workflow.add_node("topology", generate_topology)

workflow.set_entry_point("understand")

workflow.add_edge("understand", "topology")

workflow.add_edge("topology", END)

app = workflow.compile()

Testing the Workflow

To run the production-grade agent, we invoke the graph with an initial state.

result = app.invoke({"messages": ["Design an ethylene cracking process"]})

print(result["generated_topology"])

Building a Conversational AI with Claude and ChatGPT APIs: A Practical Guide

Gate of AI — Wed, 03 Jun 2026 16:06:39 +0000

🚀 Technical Briefing: This tutorial is part of our deep-dive series on Agentic Workflows at Gate of AI. For the full technical breakdown, interactive code sandbox, and the native Arabic translation, visit the original article here.

<span>Tutorial</span>
<span>Intermediate</span>
<span>⏱ 35 min read</span>
<span>© Gate of AI 2026-06-02</span>

Architect a multi-provider LLM gateway in Next.js using App Router Route Handlers to dynamically toggle production requests between OpenAI and Anthropic architectures while maintaining state context.

Prerequisites

Node.js 18.x or higher
Next.js 14.x or 15.x (App Router structure)
Valid API keys configured in the OpenAI and Anthropic developer consoles
Familiarity with polymorphic API payloads and React state composition

What We're Building

Production AI engineering often requires model redundancy or specialized routing—routing creative tasks to Claude and strict structural updates to GPT. In this guide, we are building a unified API abstraction layer that sanitizes, maps, and executes multi-turn conversations across both ecosystems cleanly.

Setup and Installation

Bootstrap a clean Next.js application layer and pull down both official vendor SDK packages:



npx create-next-app@latest multi-provider-chat --ts --no-tailwind --app --src-dir=false

cd multi-provider-chat

npm install openai @anthropic-ai/sdk

Populate your local environment matrix inside .env.local in your root directory:



OPENAI_API_KEY=your_openai_project_secret_key

ANTHROPIC_API_KEY=your_anthropic_live_secret_key

Step 1: Engineering the Unified Model Gateway

Create your server route handler at app/api/chat/route.js. We explicitly instantiate both clients and create an abstraction parser to handle the structural layout differences between OpenAI's choices array and Anthropic's content blocks.



import { NextResponse } from 'next/server';

import { OpenAI } from 'openai';

import { Anthropic } from '@anthropic-ai/sdk';

const openai = new OpenAI();

const anthropic = new Anthropic();

export async function POST(req) {

    try {

        const { provider, messages } = await req.json();

    if (!messages || !Array.isArray(messages)) {
        return NextResponse.json({ error: 'Malformed message history payload' }, { status: 400 });
    }

    let replyText = '';

    if (provider === 'openai') {
        const response = await openai.chat.completions.create({
            model: 'gpt-4o-mini',
            messages: messages.map(msg =&gt; ({
                role: msg.role,
                content: msg.content
            }))
        });
        replyText = response.choices[0].message.content;

    } else if (provider === 'anthropic') {
        // Anthropic separates the 'system' message from the historical array
        const systemMessage = messages.find(m =&gt; m.role === 'system')?.content || 'You are a precise assistant.';
        const conversationHistory = messages.filter(m =&gt; m.role !== 'system');

        const response = await anthropic.messages.create({
            model: 'claude-3-5-haiku-20241022',
            max_tokens: 1024,
            system: systemMessage,
            messages: conversationHistory.map(msg =&gt; ({
                role: msg.role === 'assistant' ? 'assistant' : 'user', // Safe role mapping
                content: msg.content
            }))
        });
        replyText = response.content[0].text;

    } else {
        return NextResponse.json({ error: 'Unsupported provider routing request' }, { status: 400 });
    }

    return NextResponse.json({ reply: replyText });

} catch (error) {
    console.error('Gateway Route Exception:', error);
    return NextResponse.json({ error: error.message || 'Internal processing error' }, { status: 500 });
}



}

Step 2: Building the Polymorphic Interface Component

Create your frontend component architecture at app/page.js. We implement standard state updater functions to maintain conversational tracking history while providing an explicit drop-down to switch providers dynamically.



'use client';

import { useState } from 'react';

export default function HomeChatWorkspace() {

    const [messages, setMessages] = useState([

        { role: 'system', content: 'You are a helpful software engineering consultant.' }

    ]);

    const [input, setInput] = useState('');

    const [provider, setProvider] = useState('openai'); // Default routing value

    const [isLoading, setIsLoading] = useState(false);

const handleFormSubmit = async (e) =&gt; {
    e.preventDefault();
    if (!input.trim() || isLoading) return;

    const incomingUserNode = { role: 'user', content: input };
    setInput('');
    setIsLoading(true);

    // Update UI state with user message immediately
    const updatedHistory = [...messages, incomingUserNode];
    setMessages(updatedHistory);

    try {
        const response = await fetch('/api/chat', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({ provider, messages: updatedHistory })
        });

        const data = await response.json();
        if (!response.ok) throw new Error(data.error || 'Server rejected request');

        setMessages((prev) =&gt; [...prev, { role: 'assistant', content: data.reply }]);
    } catch (err) {
        console.error('Inference Error:', err);
        setMessages((prev) =&gt; [...prev, { role: 'system', content: `Error: ${err.message}` }]);
    } finally {
        setIsLoading(false);
    }
};

return (


            <h2>Multi-Model Control Panel</h2>
             setProvider(e.target.value)} disabled={isLoading}&gt;
                Engine: GPT-4o-Mini
                Engine: Claude-3.5-Haiku




            {messages.filter(m =&gt; m.role !== 'system').map((msg, idx) =&gt; (

                    <span>
                        <strong>{msg.role === 'user' ? 'You' : 'AI'}:</strong> {msg.content}
                    </span>

            ))}



             setInput(e.target.value)} 
                placeholder="Ask a technical question..." 
                disabled={isLoading}
                style={{ flex: 1, padding: '10px', borderRadius: '4px', border: '1px solid #ccc' }}
            /&gt;

                {isLoading ? 'Processing...' : 'Send'}



);



}

⚠️ Advanced Ingestion Warning: Anthropic's Messages API enforces strict array alternation. If you pass consecutive messages with the same role (e.g., 'user' followed by another 'user' node), the SDK will reject the payload with a 400 validation error. Always ensure your mapping pipeline cleanses array structure sequences before firing updates to the Claude engine.

Testing Your Routing Engine

Boot your Next.js application workspace locally:

npm run dev

Open http://localhost:3000. Select GPT-4o-Mini and ask a question. Then immediately switch the dropdown option to Claude-3.5-Haiku and ask follow-up questions like "Can you rewrite my last question in Rust?" Notice how the continuous context array maps safely regardless of your provider toggle swaps.

What to Build Next

Convert the system to utilize streaming chunks concurrently across both components using ReadableStream wrappers.
Implement automated model comparison logging to measure execution latency variations between OpenAI and Anthropic routers.
Add a fall-through logic block that automatically switches providers if one vendor encounters a 503 rate-limit error.

How to Build Long-Running AI Agents with Google Gen AI SDK

Gate of AI — Sun, 31 May 2026 17:42:58 +0000

🚀 Technical Briefing: This tutorial is part of our deep-dive series on Agentic Workflows at Gate of AI. For the full technical breakdown, interactive code sandbox, and the native Arabic translation, visit the original article here.

<span>Tutorial</span>
<span>Advanced</span>
<span>⏱ 45 min read</span>
<span>© Gate of AI 2026-05-31</span>

Step away from standard chat APIs. Learn the foundational architecture for building long-running, stateful autonomous agents inspired by the new Gemini Enterprise Unified Inbox.

Prerequisites

Python 3.10 or higher
Access to the Google Gen AI SDK (Gemini 1.5 Pro or higher)
A Google Cloud Project with Billing Enabled
Advanced understanding of asynchronous Python (asyncio) and state management

What We're Building

With Google Cloud's announcement of Long-Running Agents in Gemini Enterprise, the development paradigm has officially shifted. In this tutorial, we will construct the foundational "pause-and-resume" architecture required to build these agents.

We won't just build a chatbot. We will build a stateful, asynchronous Python worker that executes a multi-step task, intentionally "pauses" when it requires simulated human approval (mimicking the Unified Inbox), and resumes upon confirmation.

Setup and Installation

We will use the official Google Gen AI SDK and python-dotenv for our environment variables.

pip install google-genai python-dotenv asyncio

Secure your API credentials in a .env file.



    # .env file

    GEMINI_API_KEY=your_gemini_api_key_here

Step 1: Architecting the Stateful Client

Unlike a standard chatbot that forgets data between queries, a long-running agent must maintain a rigid state dictionary. We initialize the official genai.Client and set up our state manager.



import os

import asyncio

from google import genai

from dotenv import load_dotenv

load_dotenv()

class LongRunningAgent:

    def init(self):

        # Initialize the official Google Gen AI Client

        self.client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))

        self.model = "gemini-1.5-pro"

    # This dictionary mimics the persistent state stored in a database
    self.state = {
        "status": "idle", # idle, running, awaiting_approval, completed
        "workflow_history": [],
        "pending_approval_request": None
    }

def log_action(self, action):
    print(f"[AGENT LOG]: {action}")
    self.state["workflow_history"].append(action)

Step 2: Building the "Pause-and-Resume" HITL Logic

The core innovation of Gemini's new update is the Human-in-the-Loop (HITL) Inbox. Here, we build the asynchronous logic that allows the agent to pause execution when it hits a restricted action.



    async def request_human_approval(self, task_description):

        """Simulates pushing a task to the Unified Inbox"""

        self.state["status"] = "awaiting_approval"

        self.state["pending_approval_request"] = task_description

    self.log_action(f"PAUSED: Awaiting human approval for: {task_description}")

    # Simulate waiting for the manager to click "Approve" in the Inbox
    while self.state["status"] == "awaiting_approval":
        await asyncio.sleep(2) # Check database/state every 2 seconds

    self.log_action("RESUMED: Human approval granted.")
    return True

def simulate_manager_approval(self):
    """External function called by your UI/Inbox when a user clicks approve"""
    if self.state["status"] == "awaiting_approval":
        self.state["status"] = "running"
        self.state["pending_approval_request"] = None
        print("\n✅ [INBOX]: Manager approved the action.\n")

Step 3: Executing the Asynchronous Workflow

Now, we tie it together. We will use the client.models.generate_content method to process data, but wrap it in our async execution loop.



    async def run_multi_day_workflow(self, initial_prompt):

        self.state["status"] = "running"

        self.log_action("Starting long-running workflow...")

    # Phase 1: Autonomous Processing
    self.log_action("Analyzing request via Gemini API...")
    response = self.client.models.generate_content(
        model=self.model,
        contents=f"Analyze this task and propose a 3-step execution plan: {initial_prompt}"
    )
    self.log_action(f"Plan generated: {response.text[:100]}...")

    # Phase 2: Hitting a permission wall (Mimicking the Unified Inbox feature)
    await asyncio.sleep(1) # Simulating heavy compute time

    # The agent realizes it needs access to a restricted system (e.g., Google Drive)
    await self.request_human_approval("Access restricted Drive Folder: 'Q3 Financials'")

    # Phase 3: Post-Approval Execution
    self.log_action("Finalizing workflow with approved access...")
    final_response = self.client.models.generate_content(
        model=self.model,
        contents="The human approved access. Generate the final summary report."
    )

    self.state["status"] = "completed"
    self.log_action("Workflow Completed.")
    return final_response.text

⚠️ Expert Tip: In a production environment, do not use asyncio.sleep to hold state. You must serialize the self.state dictionary to a persistent database (like Redis or PostgreSQL). When the webhook from your Inbox arrives, you retrieve the state and re-initialize the agent.

Testing the Unified Inbox Architecture

To run this, we will use Python's asyncio.gather to run the agent in the background while simulating a human checking their inbox.



async def main():

    agent = LongRunningAgent()

# Start the agent as a background task
agent_task = asyncio.create_task(
    agent.run_multi_day_workflow("Audit the Q3 Marketing Spend")
)

# Simulate the human manager checking their inbox after 5 seconds
await asyncio.sleep(5)
agent.simulate_manager_approval()

# Wait for the agent to finish
result = await agent_task
print(f"\n[FINAL OUTPUT]:\n{result}")



if name == 'main':

    asyncio.run(main())

What to Build Next

Replace the simulated wait loop by saving the agent's state to a PostgreSQL database.
Build a frontend React/Next.js "Unified Inbox" UI that triggers the webhook to resume the agent.
Implement the official genai.types.Tool configurations to let the agent actually execute the actions post-approval.

Building a Chatbot with Mistral's Mixtral API: A Step-by-Step Guide

Gate of AI — Sat, 23 May 2026 07:54:16 +0000

🚀 Technical Briefing: This tutorial is part of our deep-dive series on Agentic Workflows at Gate of AI. For the full technical breakdown, interactive code sandbox, and the native Arabic translation, visit the original article here.

Learn to harness the power of the official Mistral AI API to create a responsive, intelligent chatbot capable of handling complex queries with ease.

Prerequisites

Python 3.8 or higher
Access to Mistral AI API (API key required from console.mistral.ai)
Intermediate understanding of Python programming

What We're Building
In this tutorial, you will learn how to build a sophisticated chatbot using the official Mistral AI Python SDK. This chatbot will process natural language queries, provide coherent responses, and handle conversational topics by leveraging Mistral's latest models.
The finished project will be a command-line application that interacts with users, processes conversational intents, and showcases the capabilities of modern AI-driven agents.

Setup and Installation
To start, install the official Mistral SDK and python-dotenv for secure configuration.
pip install mistralai python-dotenv
Store your API key in a .env file to ensure it is not hardcoded.

# .env file
MISTRAL_API_KEY=your_api_key_here

Step 1: Setting Up the API Client
We will use the Mistral client class from the official SDK, which is the recommended way to interact with Mistral's endpoints.

import os
from mistralai import Mistral
from dotenv import load_dotenv

load_dotenv()

class ChatbotClient:
def init(self):
# Client automatically reads MISTRAL_API_KEY from environment variables
self.client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
self.model = "mistral-small-latest"

def send_query(self, query):
    response = self.client.chat.complete(
        model=self.model,
        messages=[{"role": "user", "content": query}]
    )
    return response.choices[0].message.content

Step 2: Building the Chatbot Interface
This command-line interface allows for continuous interaction with the model.

def main():
client = ChatbotClient()
print("Welcome to the Mistral Chatbot! Type 'exit' to quit.")

while True:
    user_input = input("You: ")
    if user_input.lower() == 'exit':
        print("Goodbye!")
        break

    try:
        response = client.send_query(user_input)
        print(f"Bot: {response}")
    except Exception as e:
        print(f"Error: {e}")

if name == 'main':
main()

Step 3: Enhancing with Contextual Awareness
To enable multi-turn conversations, you must maintain a list of messages that includes the conversation history.

class EnhancedChatbotClient(ChatbotClient):
def init(self):
super().init()
self.history = [{"role": "system", "content": "You are a helpful assistant."}]

def send_query_with_context(self, query):
    self.history.append({"role": "user", "content": query})

    response = self.client.chat.complete(
        model=self.model,
        messages=self.history
    )

    answer = response.choices[0].message.content
    self.history.append({"role": "assistant", "content": answer})
    return answer

⚠️ Expert Tip: Always use the official SDK's message structure. Properly defining roles ("system", "user", "assistant") is critical for maintaining coherent context.

Testing Your Implementation
Run your script and interact with the chatbot to verify the contextual memory.

Run the script

python chatbot.py

What to Build Next

Integrate the chatbot into a web application using Flask or Django.
Implement streaming responses using client.chat.stream() for a real-time typing effect.
Experiment with mistral-medium-latest or mistral-large-latest for more complex reasoning tasks.

Reverse Engineering X’s Recommendation Algorithm: Programmatic Hooks for Tech Creators

Gate of AI — Fri, 22 May 2026 23:43:26 +0000

🚀 Technical Briefing: This tutorial is part of our deep-dive series on Agentic Workflows at Gate of AI. For the full technical breakdown, interactive code sandbox, and the native Arabic translation, visit the original article here.

Tutorial
Intermediate
⏱ 8 min read
© Gate of AI
Reverse engineer the open-sourced X recommendation algorithm to write high-converting hooks and maximize your content's organic reach.

The Content Ecosystem Strategy
To build a sustainable content architecture, your website should always be the ultimate source of truth, while social platforms like YouTube and X serve as marketing funnels. This tutorial breaks down the technical secrets of the X algorithm so you can drive massive traffic back to your core platforms.

Reverse Engineering the X Algorithm
Following the recent open-source release of the X "For You" feed algorithm, developers and content creators finally have programmatic proof of what actually drives engagement. It is no longer just about likes and retweets; the core of the ranking system relies on behavioral metrics that track exactly how users interact with your text on screen.
In this guide, we will analyze the exact parameters found in the xAI repository to understand how to craft the perfect "Hook" and guarantee maximum visibility.

The Technical Secret: The "Dwell Time" Parameter
Deep within the open-source code, there is a massive weighting applied to a metric known as Dwell Time. The X algorithm actively tracks the exact amount of time a user spends reading your tweet before they scroll past it.
If your post causes a user to pause their scrolling, the algorithm immediately flags your content as "high-value." The longer they stay on the text, the higher your algorithmic score spikes. This means your primary goal as a writer is not just to deliver information, but to visually and psychologically stop the scroll within the first two seconds.
The Formula for a Programmatic Hook
Based on the code's preference for high Dwell Time, standard introductions fail because they are easily skimmable. To force the algorithm to rank your tweet higher, your hook must create instant cognitive friction.
The most effective hooks utilize two specific triggers:

The Shocking Question: Frame your opening as a question that challenges an industry standard. (e.g., "Is the era of proprietary AI models completely dead?")
The Terrifying Metric: Start with an alarming or massive data point that forces the brain to process the number. (e.g., "90% of developers are using outdated attention mechanisms. Here is why.")

These structures force the reader to pause and process the information, directly feeding the Dwell Time parameter the data it needs to boost your post.

The "Show More" Bonus Multiplier
One of the most actionable discoveries in the codebase is the Bonus Boost awarded for explicit interaction. While likes and bookmarks are valuable, the algorithm highly rewards content that prompts the user to click the "Show More" text expansion button.
From a programmatic standpoint, clicking "Show More" is registered as an explicit, high-intent positive engagement. To leverage this:

Format your tweets to be intentionally long enough to trigger the truncation limit.
Place your most compelling hook or a cliffhanger exactly where the text cuts off, making the user physically click to read the rest of the tutorial or find the link to your site.

// Conceptual representation of X's HeavyRanker feature scoring

function calculateTweetScore(tweet) {
let baseScore = tweet.likes * 0.5 + tweet.retweets * 1.0;

// The Dwell Time Multiplier (Logarithmic scaling)
if (tweet.dwellTimeSeconds &gt; 2) {
    baseScore += Math.log(tweet.dwellTimeSeconds) * 2.5;
}

// Explicit Intent Action: The "Show More" Expansion
if (tweet.isTextExpanded) {
    baseScore *= 1.4; // 40% algorithmic boost multiplier
}

return baseScore;

}

🧠 Architecture Mindset: Do not just give all the value away on the timeline. Use the "Show More" technique to tease a deeper technical secret, and place the link to your full Gate of AI article in the subsequent thread.

Have a question about this tutorial?
Our AI assistant has read this tutorial and is ready to answer all your questions instantly. Open the chat for step-by-step guidance!

Stop Relying on One LLM: Build a Dual-Engine Agent with GPT-4o & Gemini

Gate of AI — Fri, 22 May 2026 23:23:36 +0000

🚀 Technical Briefing: This tutorial is part of our deep-dive series on Agentic Workflows at Gate of AI. For the full technical breakdown, interactive code sandbox, and the native Arabic translation, visit the original article here.