DEV Community: Gate of AI

Build a Secure Node.js AI API Gateway

Gate of AI — Thu, 13 Aug 2026 18:13:39 +0000

<p>Build a small Node.js AI API gateway that accepts validated JSON, assigns request IDs, applies a local per-client limit, and forwards approved work to a server-side model service without exposing provider credentials to browser code.</p>



<h2>Prerequisites</h2>
<ul>
  <li>Node.js 18 or later. This tutorial uses the runtime’s built-in <code>http</code>, <code>crypto</code>, and <code>fetch</code> capabilities.</li>
  <li>Basic familiarity with JavaScript, JSON, HTTP requests, environment variables, and a terminal.</li>
  <li>A model service that your gateway is permitted to call over HTTP. The gateway does not contain a model or a model-provider SDK.</li>
  <li>A REST client such as <code>curl</code>, Postman, Bruno, Insomnia, or the VS Code REST Client extension.</li>
</ul>



<h2>What You Are Building</h2>
<p>This tutorial builds a deliberately small Node.js AI API gateway. A client sends a JSON request to <code>POST /api/chat</code>. The gateway checks that the request has the expected shape, rejects oversized payloads, assigns a request ID, applies a local rate limit, and forwards the validated request to a separate model service over HTTP. The gateway then returns the model service response to the caller.</p>
<p>The architectural idea is grounded in a commonly used separation of concerns: a web backend serves HTTP APIs while a model service performs the core predictive task. The verified context describes an example stack with a web frontend, load balancer, Node.js REST API backend, distributed task queue, and a model service. This article implements only the Node.js gateway boundary. It does not claim to prescribe a complete production architecture, a particular model vendor, or a particular model-serving framework.</p>
<p>Keeping the gateway separate from the model service gives an application one place to apply input rules and operational controls before work reaches an AI system. It also means browser applications call your service rather than receiving a sensitive upstream credential. The exact authentication, authorization, data-retention, safety review, and deployment requirements depend on your organisation and use case, so they are intentionally not represented as universal defaults in this example.</p>
<p>The implementation avoids unverified provider-specific SDK calls, model names, token limits, and model-response schemas. Instead, it defines a small JSON contract owned by this application. That is useful when the model service is an internal service, a separately operated inference API, or an adapter that you maintain elsewhere.</p>



<h2>Gateway Responsibilities and Boundaries</h2>
<p>A gateway should have a narrow job. In this tutorial it does five things: it accepts HTTP requests, parses limited-size JSON, validates required fields, records an opaque request ID, and forwards safe input to an upstream model service. It does not attempt to decide whether a generated answer is correct. It does not train a model. It does not embed keys in a frontend bundle. It also does not assume that every model service uses the same request or response structure.</p>
<p>Our public request contract is intentionally simple:</p>
<pre><code>{

"messages": [
{ "role": "user", "content": "Explain an API gateway." }
]
}

The gateway accepts up to 20 messages, permits only system, user, and assistant roles, and limits each message to 12,000 characters by default. These are application controls rather than token measurements. Characters and model tokens are not the same unit, so a character limit should not be presented as a precise cost or usage limit.

The upstream service in this tutorial receives a wrapper containing a request ID and the validated messages. Its expected successful response is JSON. The gateway does not transform that JSON into a vendor-neutral completion format because no provider response format is verified in the available context. Owning a small, documented internal contract is safer than guessing at a provider API.

<h2>Step 1: Create the Project and Environment File</h2>
<p>Create a new project directory. This version uses no third-party dependency, which makes the example easy to inspect and keeps its runtime surface small. The built-in Node.js HTTP server is sufficient for a focused gateway demonstration.</p>
<pre><code>mkdir nodejs-ai-api-gateway

cd nodejs-ai-api-gateway
npm init -y
npm pkg set type=module
npm pkg set scripts.start="node src/server.js"
npm pkg set scripts.dev="node --watch src/server.js"
npm pkg set engines.node=">=18.0.0"
mkdir -p src

Create a .gitignore file before creating local configuration. Never commit credentials or deployment-specific environment files to source control.

node_modules

.env

.env.local

.env.production

logs

coverage

npm-debug.log*

.DS_Store

Next, create .env. MODEL_SERVICE_URL is the only required upstream setting. The URL must point to a service that your deployment can reach and is authorised to use. The example uses a loopback URL only as a local-development value.

PORT=3001

MODEL_SERVICE_URL=http://127.0.0.1:8080/generate

ALLOWED_ORIGIN=http://localhost:3000

MAX_BODY_BYTES=262144

MAX_MESSAGE_CHARS=12000

MAX_CONVERSATION_MESSAGES=20

REQUESTS_PER_MINUTE=30

UPSTREAM_TIMEOUT_MS=30000

Do not put upstream credentials in browser-exposed environment variables. If the model service requires credentials, keep them in the gateway’s server-side deployment environment and attach them only on the server. This tutorial does not include an authorization header because its name, format, and credential lifecycle are not established by the verified context.

<h2>Step 2: Validate Configuration at Startup</h2>
<p>Create <code>src/config.js</code>. Environment variables arrive as strings, so the module explicitly parses numerical values and fails early when required configuration is invalid. Startup validation is preferable to discovering a malformed port or URL only after traffic arrives.</p>
<pre><code>import process from "node:process";

function readPositiveInteger(name, fallback, minimum, maximum) {
const raw = process.env[name] ?? String(fallback);
const value = Number.parseInt(raw, 10);

if (!Number.isInteger(value) || value < minimum || value > maximum) {
throw new Error(${name} must be an integer from ${minimum} to ${maximum}.);
}

return value;
}

function readUrl(name) {
const raw = process.env[name];

if (!raw) {
throw new Error(${name} is required.);
}

try {
return new URL(raw).toString();
} catch {
throw new Error(${name} must be a valid URL.);
}
}

export const config = Object.freeze({
port: readPositiveInteger("PORT", 3001, 1, 65535),
modelServiceUrl: readUrl("MODEL_SERVICE_URL"),
allowedOrigin: process.env.ALLOWED_ORIGIN ?? "http://localhost:3000",
maxBodyBytes: readPositiveInteger("MAX_BODY_BYTES", 262144, 1024, 1048576),
maxMessageChars: readPositiveInteger("MAX_MESSAGE_CHARS", 12000, 1, 100000),
maxConversationMessages: readPositiveInteger(
"MAX_CONVERSATION_MESSAGES",
20,
1,
100
),
requestsPerMinute: readPositiveInteger(
"REQUESTS_PER_MINUTE",
30,
1,
10000
),
upstreamTimeoutMs: readPositiveInteger(
"UPSTREAM_TIMEOUT_MS",
30000,
1000,
120000
)
});

For local development, load environment values before starting Node. One straightforward option is to export the values in your shell. Deployment platforms should inject server-side environment variables through their own protected configuration mechanism. The code above intentionally does not rely on an unverified configuration library.

<h2>Step 3: Build the Node.js Gateway</h2>
<p>Create <code>src/server.js</code>. The server is complete and uses only Node.js modules. It accepts <code>POST /api/chat</code> and <code>GET /health</code>. It handles preflight requests for one configured browser origin, but CORS is not authentication. A public gateway still needs an authentication and authorization design appropriate to its users.</p>
<pre><code>import crypto from "node:crypto";

import http from "node:http";
import { config } from "./config.js";

const rateWindows = new Map();

function sendJson(response, statusCode, body, requestId) {
const payload = JSON.stringify(body);
response.writeHead(statusCode, {
"Content-Type": "application/json; charset=utf-8",
"Content-Length": Buffer.byteLength(payload),
"X-Request-Id": requestId,
"Cache-Control": "no-store"
});
response.end(payload);
}

function getRequestId(request) {
const supplied = request.headers["x-request-id"];
if (typeof supplied === "string" && supplied.length > 0 && supplied.length <= 128) {
return supplied;
}
return crypto.randomUUID();
}

function applyCors(request, response) {
const origin = request.headers.origin;

if (origin === config.allowedOrigin) {
response.setHeader("Access-Control-Allow-Origin", origin);
response.setHeader("Vary", "Origin");
response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
response.setHeader("Access-Control-Allow-Headers", "Content-Type, X-Request-Id");
response.setHeader("Access-Control-Max-Age", "86400");
}
}

function clientKey(request) {
return request.socket.remoteAddress ?? "unknown";
}

function isRateLimited(request) {
const key = clientKey(request);
const now = Date.now();
const windowStart = now - 60_000;
const recent = (rateWindows.get(key) ?? []).filter((timestamp) => timestamp > windowStart);

if (recent.length >= config.requestsPerMinute) {
rateWindows.set(key, recent);
return true;
}

recent.push(now);
rateWindows.set(key, recent);
return false;
}

function readJsonBody(request) {
return new Promise((resolve, reject) => {
let totalBytes = 0;
const chunks = [];

request.on("data", (chunk) =&gt; {
  totalBytes += chunk.length;
  if (totalBytes &gt; config.maxBodyBytes) {
    reject(new Error("BODY_TOO_LARGE"));
    request.destroy();
    return;
  }
  chunks.push(chunk);
});

request.on("end", () =&gt; {
  try {
    const text = Buffer.concat(chunks).toString("utf8");
    resolve(JSON.parse(text));
  } catch {
    reject(new Error("INVALID_JSON"));
  }
});

request.on("error", reject);

});
}

function validateChatRequest(value) {
if (!value || typeof value !== "object" || Array.isArray(value)) {
return "Request body must be a JSON object.";
}

if (!Array.isArray(value.messages) || value.messages.length === 0) {
return "messages must be a non-empty array.";
}

if (value.messages.length > config.maxConversationMessages) {
return messages must contain at most ${config.maxConversationMessages} items.;
}

const roles = new Set(["system", "user", "assistant"]);
let systemCount = 0;

for (const message of value.messages) {
if (!message || typeof message !== "object" || Array.isArray(message)) {
return "Each message must be an object.";
}
if (!roles.has(message.role)) {
return "Each message role must be system, user, or assistant.";
}
if (typeof message.content !== "string" || message.content.trim().length === 0) {
return "Each message content value must be a non-empty string.";
}
if (message.content.length > config.maxMessageChars) {
return Each message content value must be at most ${config.maxMessageChars} characters.;
}
if (message.role === "system") systemCount += 1;
}

if (systemCount > 1) return "Only one system message is allowed.";
if (value.messages[0].role === "assistant") {
return "The first message cannot use the assistant role.";
}

return null;
}

async function forwardToModelService(input, requestId) {
const timeout = AbortSignal.timeout(config.upstreamTimeoutMs);
const upstreamResponse = await fetch(config.modelServiceUrl, {
method: "POST",
headers: {
"Content-Type": "application/json",
"X-Request-Id": requestId
},
body: JSON.stringify({ requestId, messages: input.messages }),
signal: timeout
});

const contentType = upstreamResponse.headers.get("content-type") ?? "";
const responseBody = contentType.includes("application/json")
? await upstreamResponse.json()
: { message: await upstreamResponse.text() };

return { status: upstreamResponse.status, body: responseBody };
}

const server = http.createServer(async (request, response) => {
const requestId = getRequestId(request);
applyCors(request, response);

if (request.method === "OPTIONS") {
response.writeHead(204, { "X-Request-Id": requestId });
response.end();
return;
}

if (request.method === "GET" && request.url === "/health") {
sendJson(response, 200, { status: "ok", service: "nodejs-ai-api-gateway" }, requestId);
return;
}

if (request.method !== "POST" || request.url !== "/api/chat") {
sendJson(response, 404, { error: { code: "NOT_FOUND", message: "Route not found." } }, requestId);
return;
}

if (isRateLimited(request)) {
sendJson(response, 429, { error: { code: "RATE_LIMITED", message: "Try again shortly." } }, requestId);
return;
}

if (!request.headers["content-type"]?.includes("application/json")) {
sendJson(response, 415, { error: { code: "UNSUPPORTED_MEDIA_TYPE", message: "Use application/json." } }, requestId);
return;
}

try {
const input = await readJsonBody(request);
const validationError = validateChatRequest(input);

if (validationError) {
  sendJson(response, 400, { error: { code: "INVALID_REQUEST", message: validationError } }, requestId);
  return;
}

const upstream = await forwardToModelService(input, requestId);
sendJson(response, upstream.status, { requestId, data: upstream.body }, requestId);

} catch (error) {
if (error.message === "BODY_TOO_LARGE") {
sendJson(response, 413, { error: { code: "BODY_TOO_LARGE", message: "Request body exceeds the configured limit." } }, requestId);
return;
}

if (error.message === "INVALID_JSON") {
  sendJson(response, 400, { error: { code: "INVALID_JSON", message: "Request body must contain valid JSON." } }, requestId);
  return;
}

console.error(JSON.stringify({ requestId, error: String(error) }));
sendJson(response, 502, { error: { code: "MODEL_SERVICE_ERROR", message: "The model service could not be reached or did not complete the request." } }, requestId);

}
});

server.listen(config.port, () => {
console.log(JSON.stringify({ event: "listening", port: config.port }));
});

function shutdown(signal) {
console.log(JSON.stringify({ event: "shutdown_started", signal }));
server.close(() => process.exit(0));
setTimeout(() => process.exit(1), 10_000).unref();
}

process.on("SIGINT", () => shutdown("SIGINT"));
process.on("SIGTERM", () => shutdown("SIGTERM"));

The local rate limiter uses process memory and the socket address as its key. This is suitable only for a single-process demonstration. When a service runs behind a load balancer or on multiple instances, each process has its own memory and may observe a different client address. Use a shared, deliberately designed rate-limit mechanism and authenticated identity signals before treating limits as an enforceable organisation-wide control.

The server logs only an opaque request ID and an error string in the catch path. It does not intentionally log message content. This is a practical default because prompts may contain sensitive business information, source code, or personal information. If you need content logging for a defined evaluation process, decide separately what may be retained, who may access it, and how deletion and incident response work.

<h2>Step 4: Run and Test the Gateway</h2>
<p>Set the environment variables in your shell, then start the server. The exact shell syntax differs by operating system. On a Unix-like shell, the following starts the application with the example local URL.</p>
<pre><code>export PORT=3001

export MODEL_SERVICE_URL=http://127.0.0.1:8080/generate
export ALLOWED_ORIGIN=http://localhost:3000
npm run dev

First test the health endpoint. It does not call the model service.

curl --include http://localhost:3001/health

Then send a valid chat request. This request will reach the configured model service, so it can succeed only when that service is available and implements the contract expected by your application.

curl --include --request POST http://localhost:3001/api/chat \

  --header "Content-Type: application/json" \

  --data '{

    "messages": [

      { "role": "system", "content": "Answer concisely." },

      { "role": "user", "content": "What is an API gateway?" }

    ]

  }'

Also test negative paths. Send malformed JSON to confirm the gateway returns 400. Send a request with an invalid role to verify the application-level schema. Finally, temporarily stop the model service to check the gateway’s 502 response. Failure testing is essential because network availability and upstream behaviour are not guaranteed.

curl --include --request POST http://localhost:3001/api/chat \

  --header "Content-Type: application/json" \

  --data '{"messages":[{"role":"unknown","content":"Hello"}]}'

<h2>What to Build Next</h2>
<p>Start with authentication. CORS controls which compliant browsers may read a response; it does not establish who is allowed to use an endpoint. Add an authentication mechanism appropriate to your application, then associate requests with a user, service, organisation, or tenant before applying meaningful quotas.</p>
<p>Next, define the model-service contract explicitly. Document the accepted request body, expected response body, timeout behaviour, error statuses, and versioning strategy. If you introduce a queue for long-running work, make the request lifecycle explicit rather than pretending every task will complete during one synchronous HTTP call. The verified context’s example architecture includes a distributed task queue alongside a Node.js backend and model service, which is a useful direction to evaluate for workloads that do not fit a simple request-response interaction.</p>
<p>For scale, put the gateway behind infrastructure that your team operates and monitors. The verified context describes a load balancer as part of an example production stack. If you deploy multiple gateway instances, replace the in-memory limiter with a shared approach, ensure request IDs flow through every service, and test how client address information is handled by your proxy configuration.</p>
<p>For GCC and Middle East deployments, avoid unsupported assumptions about local hosting, legal requirements, or named government programmes. Instead, have legal, security, and data-governance stakeholders assess where data is processed, what information is sent to the model service, how long records are retained, and which regional contractual or regulatory obligations apply to the specific organisation. A gateway boundary makes those controls easier to place consistently, but it does not itself establish compliance.</p>
<p>Finally, keep dependencies and runtime components patched. The verified context includes a National Vulnerability Database entry, reinforcing the practical need to monitor security advisories relevant to the software you operate. Review advisories, test upgrades, and maintain a repeatable deployment process. A compact gateway with a clear contract is easier to test, audit, and evolve than provider-specific calls scattered across browser and backend applications.</p>

Build a RAG System with OpenAI API

Gate of AI — Thu, 13 Aug 2026 18:09:13 +0000

<span>Tutorial</span>
<span>Advanced</span>
<span>⏱ 60 min read</span>
<span>© Gate of AI 2026-07-27</span>

In this tutorial, you'll build a Retrieval-Augmented Generation (RAG) system using the latest techniques to enhance your AI application's accuracy and responsiveness.

Prerequisites

Python 3.10 or higher
OpenAI API key
Familiarity with RESTful APIs and JSON

What We're Building

In this comprehensive tutorial, we will create a Retrieval-Augmented Generation (RAG) system that leverages the capabilities of modern APIs. The system will enhance the accuracy and relevance of AI-generated content by incorporating real-time data retrieval from external sources. Our final project will allow for dynamic interaction with users, providing responses informed by the latest available data, thus overcoming the limitations of static knowledge bases.

The RAG system will integrate seamlessly with existing applications, enabling developers to deploy AI solutions that are not only more informative but also contextually aware. This will be particularly useful in scenarios where up-to-date information is crucial, such as customer support, content creation, and personalized recommendations.

Setup and Installation

To get started, we need to set up our development environment by installing the necessary packages and configuring environment variables. This ensures that our application can communicate effectively with the APIs and handle data retrieval operations.

pip install openai requests

Next, we'll define our environment variables in a .env file. This file will store sensitive information such as API keys securely.



OPENAI_API_KEY=your_openai_api_key

Step 1: Setting Up the API Client

In this step, we will initialize the API client for OpenAI. This setup is crucial as it allows our application to send requests and receive responses from the API.



import os

from openai import OpenAI

  
  
  Load API key from environment variables


openai_api_key = os.getenv("OPENAI_API_KEY")

  
  
  Initialize the API client


client = OpenAI(api_key=openai_api_key)

The code above loads the API key from our .env file using the os library and initializes the client with this key. This setup ensures secure and authenticated communication with the API.

Step 2: Implementing the Retrieval Logic

In this step, we will implement the logic to retrieve relevant information from external sources. This is a critical component of the RAG system, as it enhances the model's responses with up-to-date data.



import requests

def retrieve_data(query):

    # Example external data source

    url = "https://api.example.com/search"

    params = {"q": query}

    response = requests.get(url, params=params)

    response.raise_for_status()

    return response.json()

  
  
  Example usage


data = retrieve_data("latest AI trends")

print(data)

This function uses the requests library to perform a GET request to an external API. It takes a query string, sends it to the data source, and returns the JSON response. This retrieved data will be used to augment the AI model's output.

Step 3: Integrating Retrieval with Generation

Now, let's integrate the data retrieval with the generation capabilities of the OpenAI API. This combination will enable our system to provide more accurate and contextually relevant responses.



def generate_response(prompt, retrieved_data):

    # Combine the prompt with retrieved data

    combined_input = f"{prompt}\n\nAdditional Information:\n{retrieved_data}"

# Generate response using OpenAI
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": combined_input}]
).choices[0].message['content']

return response




  
  
  Example usage


prompt = "Discuss the impact of AI on modern education."

retrieved_data = retrieve_data("AI impact on education")

output = generate_response(prompt, retrieved_data)

print("Response:", output)

In this function, we first combine the user's prompt with additional data retrieved from external sources. We then call the OpenAI API to generate a response. This approach ensures that the output is enriched with current information, making it more relevant and accurate.

⚠️ Common Mistake: Ensure that your API key is correctly set up in the environment variables. A common issue is forgetting to restart the terminal or IDE after setting up the .env file, which can lead to authentication errors.

Testing Your Implementation

It's essential to verify that the system works as expected. We'll run a series of tests to ensure that both data retrieval and response generation are functioning correctly.



  
  
  Test retrieval function


test_data = retrieve_data("test query")

assert test_data is not None, "Data retrieval failed!"

  
  
  Test generation function


test_prompt = "Explain the significance of climate change."

test_retrieved_data = retrieve_data("climate change significance")

test_output = generate_response(test_prompt, test_retrieved_data)

assert len(test_output) > 0, "Generation failed!"

These tests check that the retrieval function returns data and that the generation function produces a response. If any assertions fail, it indicates an issue with the respective component that needs addressing.

What to Build Next

Having completed this tutorial, you can extend the RAG system in several ways:

Integrate additional data sources to enhance the breadth of information available to the system.
Implement a more sophisticated aggregation method for combining retrieved data with the AI prompt.
Optimize performance by caching frequent queries to reduce latency and API costs.

Fine-Tuning LLMs with Python: A 2026 Guide

Gate of AI — Thu, 13 Aug 2026 18:09:01 +0000

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

In this tutorial, you'll learn how to fine-tune large language models using Python to improve performance on specific tasks, leveraging modern APIs and best practices for optimal results.

Prerequisites

Python 3.10 or later
Access to OpenAI API with a valid API key
Basic understanding of machine learning and NLP

What We're Building

This tutorial will guide you through the process of fine-tuning a large language model (LLM) to perform a specific task, such as sentiment analysis or conversational AI customization. By the end of this guide, you will have a fine-tuned model that can deliver responses tailored to your specific needs, whether it's improving accuracy on niche datasets or customizing the tone and style of the output.

The finished project will involve setting up the environment, preparing a dataset, configuring the model for fine-tuning, and executing the training process. You will also learn how to test the model to ensure it meets your requirements and explore potential enhancements to further refine its capabilities.

Setup and Installation

To start, you'll need to set up your development environment. This involves installing necessary Python libraries and preparing your system to handle large datasets and model computations efficiently.

pip install transformers datasets

You'll need to configure environment variables to store your API keys securely. This is crucial for accessing the OpenAI API and other cloud-based services.



  
  
  .env file


OPENAI_API_KEY=your_openai_api_key_here

Step 1: Preparing Your Dataset

The first step in fine-tuning involves preparing a high-quality dataset. This dataset should be representative of the tasks you want the model to perform better on. You might need to curate or clean the data to ensure consistency and accuracy.



import pandas as pd

  
  
  Load your dataset


dataset = pd.read_csv('your_dataset.csv')

  
  
  Inspect the dataset


print(dataset.head())

  
  
  Clean and preprocess the dataset


def preprocess(text):

    return text.strip().lower()

dataset['text'] = dataset['text'].apply(preprocess)

In this code snippet, we load a dataset using pandas and apply basic preprocessing to clean the text, which involves stripping whitespace and converting to lowercase. This ensures that our data is uniform and ready for fine-tuning.

Step 2: Configuring the Model

Next, you'll configure the language model for fine-tuning. This involves setting up the model architecture and tokenizer. The Hugging Face Transformers library provides an easy interface for this purpose.



from transformers import AutoModelForCausalLM, AutoTokenizer

  
  
  Load pre-trained model and tokenizer


model_name = "gpt-3.5-turbo"

tokenizer = AutoTokenizer.from_pretrained(model_name)

model = AutoModelForCausalLM.from_pretrained(model_name)

  
  
  Print model details


print(model.config)

Here, we load a pre-trained model and tokenizer using the Transformers library. We then print the model configuration to understand its current settings, which will help us decide on any modifications needed for fine-tuning.

Step 3: Fine-Tuning the Model

With the model configured, you can now proceed to fine-tune it using your dataset. This process involves training the model on the dataset to adjust its weights and biases, optimizing it for your specific tasks.



from transformers import Trainer, TrainingArguments

  
  
  Define training arguments


training_args = TrainingArguments(

    output_dir='./results',

    evaluation_strategy="epoch",

    per_device_train_batch_size=2,

    num_train_epochs=3,

    save_steps=10,

    save_total_limit=2,

)

  
  
  Initialize Trainer


trainer = Trainer(

    model=model,

    args=training_args,

    train_dataset=dataset,

    tokenizer=tokenizer,

)

  
  
  Start training


trainer.train()

This code sets up the training arguments and initializes a Trainer object. The training arguments include settings like batch size and number of epochs. The Trainer handles the fine-tuning process, applying the dataset to the model and adjusting its parameters.

⚠️ Common Mistake: Ensure your dataset is preprocessed correctly. Inconsistent data formats can lead to errors during training, causing the model to underperform.

Testing Your Implementation

After fine-tuning, it's crucial to test your model to verify its performance. You should check if the model meets the desired accuracy and style requirements for your specific use case.



  
  
  Test the model


test_text = "Input text for the model"

input_ids = tokenizer.encode(test_text, return_tensors='pt')

output = model.generate(input_ids)

  
  
  Decode and print output


decoded_output = tokenizer.decode(output[0], skip_special_tokens=True)

print(decoded_output)

This test script encodes a sample input text, runs it through the fine-tuned model, and decodes the output. The result should reflect the improved capabilities of your model based on the fine-tuning.

What to Build Next

Explore multi-turn conversation fine-tuning to enhance interactive applications.
Integrate your model into a web application using a framework like Flask or FastAPI.
Experiment with different datasets to fine-tune your model for various domain-specific tasks.

Build AI App with Meta Llama 3 & LangChain

Gate of AI — Thu, 13 Aug 2026 18:08:49 +0000

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

In this tutorial, you'll build a scalable generative AI application utilizing Meta's Llama 3 and LangChain for orchestrating complex workflows.

Prerequisites

Python 3.10 or higher
Meta Llama 3 API access
Basic understanding of Python and AI concepts

What We're Building

In this tutorial, we'll create a generative AI application that leverages the power of Meta's Llama 3 model. This application will be capable of generating human-like text based on prompts provided by the user. By integrating with LangChain, we will orchestrate complex workflows that include memory management, tool usage, and state persistence.

The finished project will allow users to input text prompts and receive coherent, contextually relevant responses generated by Llama 3. This application will demonstrate the capabilities of modern AI frameworks in handling natural language processing tasks with efficiency and scalability.

Setup and Installation

To start, we need to install the necessary libraries that will allow us to interact with Meta Llama 3 and LangChain. Ensure that you have Python 3.10 or higher installed on your system.

pip install torch langchain

Next, configure the environment variables required for accessing the Llama 3 API. Create a .env file in your project directory with the following variables:

LLAMA_API_KEY=your_llama_api_key_here

LANGCHAIN_API_KEY=your_langchain_api_key_here

Step 1: Initializing the Llama 3 Model

In this step, we'll set up the Llama 3 model using the torch library. This will involve initializing the model with the API key and preparing it for text generation.

from torch import Llama3

  
  
  Initialize the Llama 3 model


llama_model = Llama3(api_key="your_llama_api_key_here")

  
  
  Set model parameters


llama_model.configure(max_length=150, temperature=0.7)

Here, we initialize the Llama 3 model by passing the API key. The configure method is used to set parameters such as max_length which determines the maximum length of generated text, and temperature which controls the randomness of the output.

Step 2: Integrating with LangChain

LangChain helps manage the orchestration of AI models and tools. We'll create a LangChain agent that interfaces with Llama 3 for generating text based on user inputs.

from langchain import LangChain

  
  
  Initialize LangChain


langchain = LangChain(api_key="your_langchain_api_key_here")

  
  
  Register the Llama 3 model as a tool


langchain.register_tool("text_generator", llama_model)

In this step, we initialize a LangChain and register our Llama 3 model as a tool named "text_generator". This allows the agent to invoke the model for text generation tasks.

Step 3: Developing the Application Interface

Now, let's create a simple interface for our application where users can input prompts and receive generated text responses.

def generate_response(prompt):

    # Use LangChain to generate text

    response = langchain.invoke_tool("text_generator", input_data=prompt)

    return response

  
  
  Example usage


user_prompt = "Tell me a story about a brave knight."

print(generate_response(user_prompt))

The generate_response function takes a user prompt and uses the LangChain to invoke the Llama 3 model. The generated response is then returned and can be printed or used in further application logic.

⚠️ Common Mistake: Ensure your API keys are valid and correctly set in the environment variables. Invalid keys will result in authentication errors.

Testing Your Implementation

To verify your application works correctly, run the script and input various prompts. You should receive coherent and contextually relevant responses from the Llama 3 model.

python your_script.py

Check the console output for the generated text. If the responses are not as expected, revisit the configuration and ensure the model parameters are set appropriately.

What to Build Next

Once you've built this basic application, consider extending it with the following projects:

Integrate a user-friendly web interface using Flask or Django.
Expand the application to handle multiple languages with additional model configurations.
Implement a persistent memory feature to maintain context across multiple interactions.

Build a Governance-Aware AI Sandbox with Node.js

Gate of AI — Thu, 13 Aug 2026 18:08:34 +0000

<span>Tutorial</span>
<span>Advanced</span>
<span>⏱ 120 min read</span>
<span>© Gate of AI 2026-07-30</span>

Learn how to build a governance-aware AI sandbox using Node.js and Express, complete with RBAC, middleware, and AI integration, leveraging the latest AI governance features.

Prerequisites

Node.js 18.x
Express 5.x
TypeScript 5.4
API keys for OpenAI and Hugging Face
Advanced understanding of backend development

What We're Building

In this tutorial, we will create a robust backend system using Node.js and Express, designed to enforce governance rules and manage AI services securely. The system will feature a modular monolithic architecture with middleware for token validation, RBAC (Role-Based Access Control), and project-level scoping. It will also integrate external AI services like OpenAI and Hugging Face to perform inference tasks.

The AI sandbox will serve as a controlled environment where developers can experiment with AI models while adhering to strict governance policies. This is particularly useful for organizations that need to ensure compliance and security in AI-driven applications, aligning with initiatives like Saudi Vision 2030.

Setup and Installation

We'll start by setting up the project environment. This involves installing Node.js, Express, and TypeScript, as well as configuring the necessary environment variables for API access.

npm install express@5.x typescript@5.4 better-sqlite3 dotenv

Next, create a .env file to store API keys and other sensitive information securely. This file should not be committed to your version control system.



API_KEY_OPENAI=your_openai_api_key

API_KEY_HF=your_huggingface_api_key

DB_PATH=./database.sqlite

Step 1: Setting Up the Express Server

In this step, we will set up a basic Express server with TypeScript. This server will serve as the foundation of our AI sandbox.



import express, { Request, Response, NextFunction } from 'express';

import dotenv from 'dotenv';

dotenv.config();

const app = express();

const PORT = process.env.PORT || 3000;

app.use(express.json());

app.get('/', (req: Request, res: Response) => {

  res.send('Welcome to the AI Sandbox!');

});

app.listen(PORT, () => {

  console.log(Server is running on port ${PORT});

});

Here, we import necessary modules, configure environment variables, and set up an Express application. We define a basic route to test the server setup and start the server on the specified port.

Step 2: Implementing Middleware for Governance

Middleware plays a crucial role in enforcing governance rules. We will implement middleware for token validation and RBAC.



function tokenValidation(req: Request, res: Response, next: NextFunction) {

  const token = req.headers['authorization'];

  if (token === process.env.VALID_TOKEN) {

    next();

  } else {

    res.status(403).send('Forbidden');

  }

}

function rbacMiddleware(role: string) {

  return (req: Request, res: Response, next: NextFunction) => {

    const userRole = req.headers['x-user-role'];

    if (userRole === role) {

      next();

    } else {

      res.status(403).send('Access Denied');

    }

  };

}

app.use(tokenValidation);

app.use(rbacMiddleware('admin'));

The tokenValidation middleware checks if the request contains a valid authorization token. The rbacMiddleware function is a factory that returns middleware enforcing role-based access control for a specific role.

Step 3: Integrating AI Services

In this step, we will integrate AI services using OpenAI and Hugging Face APIs. This allows our sandbox to perform AI tasks such as text generation or sentiment analysis.



import { OpenAI } from 'openai';

import axios from 'axios';

const openai = new OpenAI(process.env.API_KEY_OPENAI);

app.post('/generate-text', async (req: Request, res: Response) => {

  try {

    const { prompt } = req.body;

    const response = await openai.chat.completions.create({

      model: 'gpt-4o',

      messages: [{ role: 'user', content: prompt }]

    });

    res.json(response.choices[0].message);

  } catch (error) {

    res.status(500).send('Error generating text');

  }

});

app.post('/analyze-sentiment', async (req: Request, res: Response) => {

  try {

    const { text } = req.body;

    const response = await axios.post('https://api-inference.huggingface.co/models/sentiment-analysis', { inputs: text }, {

      headers: { Authorization: Bearer ${process.env.API_KEY_HF} }

    });

    res.json(response.data);

  } catch (error) {

    res.status(500).send('Error analyzing sentiment');

  }

});

We initialize the OpenAI client and define endpoints for text generation and sentiment analysis. These endpoints use the respective APIs to process requests and return results.

⚠️ Common Mistake: Ensure that your API keys are correctly set in the environment variables and that your server has internet access to connect to external APIs.

Testing Your Implementation

To verify the implementation, use tools like Postman to send requests to the endpoints. Ensure that the middleware correctly enforces governance rules, and the AI services return expected results.



curl -X POST http://localhost:3000/generate-text \

-H "Content-Type: application/json" \

-H "Authorization: Bearer YOUR_VALID_TOKEN" \

-d '{"prompt": "Hello AI"}'

curl -X POST http://localhost:3000/analyze-sentiment \

-H "Content-Type: application/json" \

-H "Authorization: Bearer YOUR_VALID_TOKEN" \

-d '{"text": "I love programming!"}'

What to Build Next

Extend the sandbox to support more AI models and tasks.
Implement a UI using Next.js to interact with the AI sandbox.
Integrate logging and monitoring to track usage and performance.

FastAPI Mistral Ticket Router: Safe GCC Guide

Gate of AI — Thu, 13 Aug 2026 18:08:19 +0000

Build a secure FastAPI ticket-routing foundation with strict request validation, deterministic escalation policies, SQLite audit records, and a safe integration boundary for a verified Mistral API implementation.

Important Accuracy Note Before You Start

The supplied source material confirms that Mistral AI is a Paris-based AI company and describes it as an OpenAI competitor. It does not provide official API documentation, supported model IDs, Python SDK package details, chat-completion method signatures, structured-output parameters, pricing, regional hosting commitments, or deployment guarantees.

For that reason, this tutorial does not present unverified Mistral SDK code as production-ready fact. Instead, it builds a complete, runnable FastAPI ticket router with a deterministic local classifier and a clearly defined provider boundary. After consulting current official Mistral documentation and completing your own evaluation, replace the local classifier implementation at that boundary with the verified Mistral integration appropriate to your account and approved model.

This is a safer engineering approach than copying an unverified model alias, SDK method, or JSON-mode option into a customer-facing workflow. The rest of the service—input contracts, audit storage, authorization, routing policy, tests, and operational controls—remains useful regardless of which approved AI provider or model you connect later.

What You Will Build

You will build a FastAPI service exposing POST /tickets/classify. A client sends a support ticket with a ticket ID, subject, body, customer tier, and source. The service validates the request, classifies it into a limited taxonomy, applies deterministic escalation rules, records an audit event in SQLite, and returns a typed JSON response.

The working baseline intentionally uses transparent keyword rules rather than pretending that an unverified external model call is available. It is not intended to replace an evaluated LLM. Its purpose is to give your team a safe, testable routing baseline and a precise interface for an eventual Mistral-backed classifier.

This architecture is useful for service desks, customer support teams, internal IT queues, security intake, logistics exceptions, and account-management workflows. It is particularly relevant in GCC organisations adopting AI under programmes such as Saudi Vision 2030 and the UAE National Strategy for Artificial Intelligence: automation should preserve review paths, clear ownership, and auditable decisions when tickets may contain customer, employee, or security-sensitive information.

Prerequisites and Installation

Python 3.10 or newer.
Basic familiarity with virtual environments, HTTP APIs, and JSON.
FastAPI, Uvicorn, Pydantic Settings, and pytest.
A future Mistral API account only when you are ready to implement the provider adapter from current official documentation.

Create the project and install dependencies:

mkdir fastapi-ticket-router
cd fastapi-ticket-router

python3 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip

cat > requirements.txt <<'EOF'
fastapi>=0.115.0
uvicorn[standard]>=0.30.0
pydantic>=2.8.0
pydantic-settings>=2.4.0
pytest>=8.3.0
EOF

pip install -r requirements.txt
mkdir -p app tests
touch app/__init__.py

Create a local environment file. The application API key protects your own endpoint; it is separate from any future AI-provider credential. Do not commit this file to source control.

cat > .env <<'EOF'
APP_API_KEY=replace-with-a-long-random-secret
DATABASE_PATH=./ticket_router.db
MAX_TICKET_CHARACTERS=12000
EOF

cat > .gitignore <<'EOF'
.venv/
.env
__pycache__/
.pytest_cache/
*.pyc
ticket_router.db
EOF

For production, place secrets in the encrypted secret-management facility approved by your cloud or platform team. Never send an AI-provider API key to browser JavaScript, mobile clients, public repositories, or client-side environment variables.

Step 1: Define Strict Contracts and Configuration

LLM integration should sit behind a deterministic API contract. Downstream systems should receive a finite set of categories, bounded confidence values, and explicit review flags—not arbitrary free-form text. Create app/config.py and app/schemas.py:

cat > app/config.py <<'EOF'
from functools import lru_cache
from pydantic import Field, SecretStr
from pydantic_settings import BaseSettings, SettingsConfigDict


class Settings(BaseSettings):
    model_config = SettingsConfigDict(env_file=".env", extra="ignore")
    app_api_key: SecretStr
    database_path: str = "./ticket_router.db"
    max_ticket_characters: int = Field(default=12000, ge=500, le=50000)


@lru_cache
def get_settings() -> Settings:
    return Settings()
EOF

cat > app/schemas.py <<'EOF'
from enum import Enum
from pydantic import BaseModel, Field, field_validator


class CustomerTier(str, Enum):
    free = "free"
    standard = "standard"
    business = "business"
    enterprise = "enterprise"


class TicketCategory(str, Enum):
    billing = "billing"
    account_access = "account_access"
    technical_issue = "technical_issue"
    security = "security"
    sales = "sales"
    feature_request = "feature_request"
    cancellation = "cancellation"
    abuse = "abuse"
    other = "other"


class Urgency(str, Enum):
    low = "low"
    normal = "normal"
    high = "high"
    critical = "critical"


class TicketInput(BaseModel):
    ticket_id: str = Field(min_length=3, max_length=100, pattern=r"^[A-Za-z0-9_-]+$")
    subject: str = Field(min_length=3, max_length=300)
    body: str = Field(min_length=10, max_length=12000)
    customer_tier: CustomerTier = CustomerTier.standard
    source: str = Field(default="api", max_length=50)

    @field_validator("subject", "body")
    @classmethod
    def reject_blank_text(cls, value: str) -> str:
        value = value.strip()
        if not value:
            raise ValueError("must not be blank")
        return value


class ClassificationResult(BaseModel):
    category: TicketCategory
    urgency: Urgency
    confidence: float = Field(ge=0.0, le=1.0)
    recommended_team: str = Field(min_length=2, max_length=80)
    customer_summary: str = Field(min_length=10, max_length=500)
    requires_human_review: bool
    review_reason: str | None = Field(default=None, max_length=300)


class ClassificationResponse(BaseModel):
    ticket_id: str
    classifier: str
    result: ClassificationResult
EOF

The enums are a safety boundary. If a future AI model proposes a category outside this list, validate and reject it before any routing action occurs. Keep prompt instructions, provider output, and final routing policy separate.

Step 2: Add the Deterministic Classifier and Policy Layer

Create a baseline classifier. Security-related language is always routed to Security Operations and always requires human review. This is deliberate: high-risk escalation should not depend solely on a probability returned by a model.

cat > app/classifier.py <<'EOF'
from app.schemas import ClassificationResult, TicketCategory, TicketInput, Urgency

SECURITY_TERMS = ("api key", "credential", "breach", "compromised", "unauthorized", "fraud")
BILLING_TERMS = ("invoice", "refund", "charge", "payment", "subscription")
ACCESS_TERMS = ("login", "password", "mfa", "sso", "locked out")
TECHNICAL_TERMS = ("error", "outage", "bug", "api", "integration", "slow")


def apply_safety_policy(result: ClassificationResult) -> ClassificationResult:
    updated = result.model_copy(deep=True)
    if updated.category == TicketCategory.security:
        updated.recommended_team = "Security Operations"
        updated.requires_human_review = True
        updated.review_reason = "Security-related ticket requires human verification."
    elif updated.urgency == Urgency.critical:
        updated.requires_human_review = True
        updated.review_reason = "Critical urgency requires immediate human review."
    elif updated.confidence < 0.70:
        updated.requires_human_review = True
        updated.review_reason = "Confidence is below the automated-routing threshold."
    elif not updated.requires_human_review:
        updated.review_reason = None
    return updated


def classify_ticket(ticket: TicketInput) -> ClassificationResult:
    text = f"{ticket.subject} {ticket.body}".lower()
    category = TicketCategory.other
    team = "General Support"
    urgency = Urgency.normal
    confidence = 0.72

    if any(term in text for term in SECURITY_TERMS):
        category, team, urgency, confidence = TicketCategory.security, "Security Operations", Urgency.high, 0.90
    elif any(term in text for term in BILLING_TERMS):
        category, team, confidence = TicketCategory.billing, "Billing Support", 0.82
    elif any(term in text for term in ACCESS_TERMS):
        category, team, confidence = TicketCategory.account_access, "Identity Support", 0.82
    elif any(term in text for term in TECHNICAL_TERMS):
        category, team, confidence = TicketCategory.technical_issue, "Technical Support", 0.78

    result = ClassificationResult(
        category=category,
        urgency=urgency,
        confidence=confidence,
        recommended_team=team,
        customer_summary=f"Ticket received: {ticket.subject}",
        requires_human_review=False,
        review_reason=None,
    )
    return apply_safety_policy(result)
EOF

When implementing the future Mistral adapter, preserve the function contract: accept TicketInput, return ClassificationResult, validate all provider output with Pydantic, and call apply_safety_policy after validation. Do not let a provider response directly select an operational queue.

Step 3: Store Audit Records in SQLite

An audit record should identify the ticket, classifier, final validated decision, and timestamp. SQLite is suitable for local development, demos, and single-instance low-volume services. Use a managed relational database with backups, access controls, and migrations for larger production workloads.

cat > app/database.py <<'EOF'
import json
import sqlite3
from datetime import datetime, timezone
from pathlib import Path
from app.schemas import ClassificationResponse


def connection(path: str) -> sqlite3.Connection:
    Path(path).parent.mkdir(parents=True, exist_ok=True)
    return sqlite3.connect(path)


def initialize_database(path: str) -> None:
    with connection(path) as db:
        db.execute("""
        CREATE TABLE IF NOT EXISTS ticket_audits (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            ticket_id TEXT NOT NULL,
            classifier TEXT NOT NULL,
            result_json TEXT NOT NULL,
            created_at TEXT NOT NULL
        )
        """)


def save_audit(path: str, response: ClassificationResponse) -> None:
    with connection(path) as db:
        db.execute(
            "INSERT INTO ticket_audits(ticket_id, classifier, result_json, created_at) VALUES (?, ?, ?, ?)",
            (response.ticket_id, response.classifier,
             json.dumps(response.result.model_dump(mode="json")),
             datetime.now(timezone.utc).isoformat()),
        )
EOF

Audit data can contain personal or commercially sensitive information. Define retention, deletion, access, encryption, and incident-response procedures before processing production tickets. GCC deployments should also assess applicable contractual, sectoral, and data-residency requirements with qualified legal and security stakeholders rather than assuming that a particular cloud or AI configuration meets local obligations.

Step 4: Expose the FastAPI Endpoint

cat > app/main.py <<'EOF'
import hmac
from contextlib import asynccontextmanager
from fastapi import Depends, FastAPI, Header, HTTPException, status
from app.classifier import classify_ticket
from app.config import Settings, get_settings
from app.database import initialize_database, save_audit
from app.schemas import ClassificationResponse, TicketInput


@asynccontextmanager
async def lifespan(app: FastAPI):
    initialize_database(get_settings().database_path)
    yield


app = FastAPI(title="FastAPI Ticket Router", version="1.0.0", lifespan=lifespan)


def require_api_key(
    x_api_key: str | None = Header(default=None, alias="X-API-Key"),
    settings: Settings = Depends(get_settings),
) -> None:
    expected = settings.app_api_key.get_secret_value()
    if x_api_key is None or not hmac.compare_digest(x_api_key, expected):
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid or missing API key")


@app.get("/health")
async def health() -> dict[str, str]:
    return {"status": "ok"}


@app.post("/tickets/classify", response_model=ClassificationResponse, dependencies=[Depends(require_api_key)])
async def route_ticket(ticket: TicketInput, settings: Settings = Depends(get_settings)) -> ClassificationResponse:
    if len(ticket.body) > settings.max_ticket_characters:
        raise HTTPException(status_code=422, detail="Ticket body exceeds configured maximum")
    response = ClassificationResponse(
        ticket_id=ticket.ticket_id,
        classifier="deterministic-baseline",
        result=classify_ticket(ticket),
    )
    save_audit(settings.database_path, response)
    return response
EOF

uvicorn app.main:app --reload --host 127.0.0.1 --port 8000

Test the endpoint in another terminal:

curl --request POST http://127.0.0.1:8000/tickets/classify \
  --header "Content-Type: application/json" \
  --header "X-API-Key: replace-with-a-long-random-secret" \
  --data '{"ticket_id":"SUP-1042","subject":"Possible API key exposure","body":"A production API key appeared in CI logs. Please investigate unauthorized use.","customer_tier":"enterprise","source":"support"}'

The response must route the ticket to Security Operations and set requires_human_review to true. This is enforced by code, not by an optional model instruction.

Test the Non-Negotiable Policy

cat > tests/test_policy.py <<'EOF'
from app.classifier import classify_ticket
from app.schemas import TicketInput


def test_security_ticket_requires_human_review() -> None:
    result = classify_ticket(TicketInput(
        ticket_id="SUP-1",
        subject="Credential exposure",
        body="Our API key may be compromised and used by an unknown party.",
    ))
    assert result.recommended_team == "Security Operations"
    assert result.requires_human_review is True
    assert result.review_reason is not None
EOF

pytest -q

Do not unit-test live provider calls as part of the standard test suite. Live calls are network-dependent, potentially billable, and variable. Instead, use unit tests for schemas and deterministic policy; then run controlled integration tests against an approved provider environment using sanitized fixtures.

Replacing the Baseline with a Verified Mistral Integration

Before changing the classifier, obtain the current official Mistral documentation for your account and verify the SDK version, authentication approach, supported model ID, request schema, response schema, structured-output option, error handling, rate limits, and data-processing terms. None of these implementation details are established in the supplied context.

Implement the provider adapter behind the existing classifier boundary. Serialize ticket content as data rather than instructions; validate the resulting JSON against ClassificationResult; reject malformed or out-of-taxonomy values; record the approved model identifier in the audit trail; and apply apply_safety_policy after the model output is validated.

Evaluate the integration on a versioned, sanitized dataset before release. Track category quality, security false negatives, human-review rate, latency, schema-valid response rate, override rate, and cost per ticket. For critical security, financial, healthcare, or public-sector workflows, design a safe failure mode: if the AI provider is unavailable or output validation fails, send the ticket to a human-review queue instead of silently guessing.

For organisations working with SDAIA, G42, NEOM, stc, e&, or other regional enterprises, the key question is not simply whether an AI model can classify a ticket. The production question is whether the end-to-end system has approved data handling, accountable operators, reliable auditability, and a documented escalation path. This FastAPI foundation supports that discipline while leaving the model provider replaceable.

Python OpenAI Structured JSON Tutorial

Gate of AI — Thu, 13 Aug 2026 18:08:05 +0000

Tutorial

Python Structured JSON Extraction with OpenAI

Build a Python command-line tool that loads travel-journal files, requests JSON-shaped extraction from an OpenAI chat model, validates every response with Pydantic, and writes a reusable report.

What You Will Build

This tutorial builds travel_journal_analyzer, a small but production-minded Python application. It accepts a text, Markdown, CSV file, or a directory containing those formats. It converts each source into a consistent JournalEntry, sends the entry to an OpenAI chat model, validates the returned JSON locally, and writes one JSON report for downstream software.

The report has a deliberately narrow purpose: identify cities mentioned in an entry, explicitly named restaurants, dishes, ratings where stated, sentiment, practical tips, and a concise summary. The application does not treat a valid JSON shape as proof that a claim is true. Its prompt instructs the model to extract facts only from the supplied entry, while local validation checks the data contract before results are exported.

Reliable structured extraction combines two boundaries. The first is the requested JSON schema: it defines the fields an application expects. The second is local validation with Pydantic: it rejects malformed values, such as a rating outside a five-point range. Research on structured generation describes the importance of reliable, typed output for applications that need predictable data rather than unconstrained prose. In practical Python work, these boundaries make testing and maintenance substantially easier.

Prerequisites and Setup

Python 3.10 or later.
An OpenAI API key and access to a chat model configured through an environment variable.
Basic familiarity with a terminal, files, and Python functions.

Create a project and isolated virtual environment:

mkdir travel-journal-analyzer
cd travel-journal-analyzer
python -m venv .venv

# macOS or Linux
source .venv/bin/activate

# Windows PowerShell
# .venv\Scripts\Activate.ps1

python -m pip install --upgrade pip
python -m pip install "openai>=1.0.0" "pydantic>=2.7.0" "python-dotenv>=1.0.1" "pytest>=8.0.0"
mkdir data output tests

Create .env. Keep this file out of source control. API keys belong in environment variables locally and in a deployment secret manager in production.

OPENAI_API_KEY=your-api-key
OPENAI_MODEL=your-chat-model
MAX_ENTRY_CHARACTERS=12000
REQUEST_TIMEOUT_SECONDS=45

Create .gitignore:

.env
.venv/
__pycache__/
.pytest_cache/
output/
*.pyc

This tutorial uses the modern client-based OpenAI Python pattern: from openai import OpenAI, then client.chat.completions.create(...). Do not use legacy module-level completion calls.

Step 1: Define the Data Contract

Create models.py. Nullable fields represent facts that the source did not provide. That is preferable to inventing a city, cuisine, or rating.

from __future__ import annotations

from typing import Literal
from pydantic import BaseModel, Field, field_validator


class JournalEntry(BaseModel):
    source_name: str = Field(min_length=1, max_length=255)
    entry_id: str = Field(min_length=1, max_length=100)
    text: str = Field(min_length=1)

    @field_validator("text")
    @classmethod
    def validate_text(cls, value: str) -> str:
        cleaned = value.strip()
        if not cleaned:
            raise ValueError("Journal entry text cannot be blank.")
        return cleaned


class RestaurantFinding(BaseModel):
    name: str = Field(min_length=1, max_length=200)
    city: str | None = Field(default=None, max_length=120)
    country: str | None = Field(default=None, max_length=120)
    cuisine: str | None = Field(default=None, max_length=120)
    dishes: list[str] = Field(default_factory=list)
    rating_out_of_five: float | None = Field(default=None, ge=0, le=5)
    sentiment: Literal["positive", "neutral", "negative"]
    recommendation_reason: str = Field(min_length=1, max_length=600)


class JournalAnalysis(BaseModel):
    entry_id: str = Field(min_length=1, max_length=100)
    cities_mentioned: list[str] = Field(default_factory=list)
    restaurants: list[RestaurantFinding] = Field(default_factory=list)
    travel_tips: list[str] = Field(default_factory=list)
    concise_summary: str = Field(min_length=1, max_length=1000)


class AnalysisReport(BaseModel):
    generated_at_utc: str
    model: str
    total_entries: int = Field(ge=0)
    successful_analyses: int = Field(ge=0)
    failed_entries: list[str] = Field(default_factory=list)
    analyses: list[JournalAnalysis] = Field(default_factory=list)

The models are not merely documentation. JournalAnalysis.model_validate_json() turns the model response into a validated object. A response with an invalid sentiment label or a six-point rating fails before it reaches a database, spreadsheet, or customer-facing interface.

Step 2: Load Text and CSV Inputs

Create journal_loader.py. Plain-text and Markdown files create one entry each. A CSV file requires a text column and creates one entry for every non-empty row. The character limit prevents unexpectedly large requests.

from __future__ import annotations

import csv
from pathlib import Path
from models import JournalEntry

SUPPORTED_SUFFIXES = {".txt", ".md", ".csv"}


def load_journal_entries(path_value: str, max_characters: int) -> list[JournalEntry]:
    path = Path(path_value).expanduser().resolve()
    if not path.exists():
        raise FileNotFoundError(f"Input path does not exist: {path}")

    if path.is_dir():
        entries: list[JournalEntry] = []
        for child in sorted(path.iterdir()):
            if child.is_file() and child.suffix.lower() in SUPPORTED_SUFFIXES:
                entries.extend(load_journal_entries(str(child), max_characters))
        if not entries:
            raise ValueError("Directory contains no supported input files.")
        return entries

    if path.suffix.lower() in {".txt", ".md"}:
        text = path.read_text(encoding="utf-8").strip()
        _check_length(text, path.name, max_characters)
        return [JournalEntry(source_name=path.name, entry_id=path.stem, text=text)]

    if path.suffix.lower() != ".csv":
        raise ValueError("Use a .txt, .md, .csv file, or directory.")

    entries = []
    with path.open("r", encoding="utf-8-sig", newline="") as handle:
        reader = csv.DictReader(handle)
        if not reader.fieldnames or "text" not in reader.fieldnames:
            raise ValueError("CSV must contain a column named 'text'.")
        for row_number, row in enumerate(reader, start=2):
            text = (row.get("text") or "").strip()
            if not text:
                continue
            _check_length(text, f"{path.name} row {row_number}", max_characters)
            entries.append(JournalEntry(
                source_name=(row.get("source_name") or path.name).strip(),
                entry_id=(row.get("entry_id") or f"{path.stem}-{row_number}").strip(),
                text=text,
            ))
    if not entries:
        raise ValueError("CSV contains no non-empty text rows.")
    return entries


def _check_length(text: str, label: str, maximum: int) -> None:
    if not text:
        raise ValueError(f"{label} is empty.")
    if len(text) > maximum:
        raise ValueError(f"{label} exceeds the {maximum}-character limit.")

Save this sample as data/journal.txt:

We arrived in Lisbon on a rainy Thursday.
For dinner, we booked Taberna da Rua das Flores. The grilled octopus was tender,
and I would rate the experience 4.5 out of 5. Reserve ahead because it is small.

Two days later in Porto, Cafe Santiago served a memorable francesinha.
The sandwich was rich but the service was slow, so I felt neutral overall.

Step 3: Request JSON and Validate It

Create analyzer.py. The schema below is passed as a requested response format. Your configured model must support the selected response-format capability; verify that support in the current OpenAI documentation for the model available to your account before deploying. Regardless of the upstream response constraint, the code performs local Pydantic validation.

from __future__ import annotations

from openai import OpenAI
from pydantic import ValidationError

from models import JournalAnalysis, JournalEntry

SCHEMA = {
    "name": "travel_journal_analysis",
    "strict": True,
    "schema": {
        "type": "object",
        "additionalProperties": False,
        "properties": {
            "entry_id": {"type": "string"},
            "cities_mentioned": {"type": "array", "items": {"type": "string"}},
            "restaurants": {"type": "array", "items": {"type": "object", "additionalProperties": False, "properties": {
                "name": {"type": "string"}, "city": {"type": ["string", "null"]},
                "country": {"type": ["string", "null"]}, "cuisine": {"type": ["string", "null"]},
                "dishes": {"type": "array", "items": {"type": "string"}},
                "rating_out_of_five": {"type": ["number", "null"]},
                "sentiment": {"type": "string", "enum": ["positive", "neutral", "negative"]},
                "recommendation_reason": {"type": "string"}
            }, "required": ["name", "city", "country", "cuisine", "dishes", "rating_out_of_five", "sentiment", "recommendation_reason"]}},
            "travel_tips": {"type": "array", "items": {"type": "string"}},
            "concise_summary": {"type": "string"}
        },
        "required": ["entry_id", "cities_mentioned", "restaurants", "travel_tips", "concise_summary"]
    }
}

SYSTEM_PROMPT = """Extract facts only from the journal entry.
Include restaurants only when explicitly named. Never invent facts.
Use null for unknown scalar values. Return only schema-conforming JSON."""


class JournalAnalyzer:
    def __init__(self, api_key: str, model: str, timeout: float) -> None:
        self.model = model
        self.client = OpenAI(api_key=api_key, timeout=timeout, max_retries=0)

    def analyze(self, entry: JournalEntry) -> JournalAnalysis:
        completion = self.client.chat.completions.create(
            model=self.model,
            temperature=0,
            response_format={"type": "json_schema", "json_schema": SCHEMA},
            messages=[
                {"role": "system", "content": SYSTEM_PROMPT},
                {"role": "user", "content": f"Required entry_id: {entry.entry_id}\n\nJournal:\n{entry.text}"},
            ],
        )
        content = completion.choices[0].message.content
        if not content:
            raise RuntimeError("The model returned an empty response.")
        try:
            result = JournalAnalysis.model_validate_json(content)
        except ValidationError as error:
            raise RuntimeError(f"Local schema validation failed: {error}") from error
        if result.entry_id != entry.entry_id:
            raise RuntimeError("Response entry_id does not match the input entry.")
        return result

The extraction policy is intentionally conservative. An unnamed kiosk may be discussed negatively in a journal, but it must not become an invented restaurant record. If unnamed venues matter to the product, add a distinct field and clearly communicate that it represents an unnamed mention, not an official venue identity.

Step 4: Create the Command-Line Application

from __future__ import annotations

import argparse
import os
from datetime import datetime, timezone
from pathlib import Path
from dotenv import load_dotenv

from analyzer import JournalAnalyzer
from journal_loader import load_journal_entries
from models import AnalysisReport


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument("input_path")
    parser.add_argument("--output", default="output/travel-analysis.json")
    args = parser.parse_args()

    load_dotenv()
    api_key = os.getenv("OPENAI_API_KEY", "").strip()
    model = os.getenv("OPENAI_MODEL", "").strip()
    if not api_key or not model:
        raise RuntimeError("Set OPENAI_API_KEY and OPENAI_MODEL in .env or your shell.")

    maximum = int(os.getenv("MAX_ENTRY_CHARACTERS", "12000"))
    timeout = float(os.getenv("REQUEST_TIMEOUT_SECONDS", "45"))
    entries = load_journal_entries(args.input_path, maximum)
    analyzer = JournalAnalyzer(api_key, model, timeout)

    analyses = []
    failed = []
    for entry in entries:
        try:
            analyses.append(analyzer.analyze(entry))
        except RuntimeError as error:
            failed.append(entry.entry_id)
            print(f"Failed {entry.entry_id}: {error}")

    report = AnalysisReport(
        generated_at_utc=datetime.now(timezone.utc).isoformat(),
        model=model,
        total_entries=len(entries),
        successful_analyses=len(analyses),
        failed_entries=failed,
        analyses=analyses,
    )
    destination = Path(args.output)
    destination.parent.mkdir(parents=True, exist_ok=True)
    temporary = destination.with_suffix(destination.suffix + ".tmp")
    temporary.write_text(report.model_dump_json(indent=2), encoding="utf-8")
    temporary.replace(destination)
    print(f"Wrote {report.successful_analyses}/{report.total_entries} analyses to {destination}")
    return 1 if failed else 0


if __name__ == "__main__":
    raise SystemExit(main())

Run the tool and inspect the output:

python main.py data/journal.txt --output output/journal-report.json
python -m json.tool output/journal-report.json

The temporary-file replacement avoids leaving a partially written final report if the process stops during serialization. The process returns a non-zero status when one or more entries fail, which is useful in scheduled jobs and CI.

Testing and Production Checks

Test deterministic components without calling an API. For example, verify that the loader rejects a CSV without a text column, that blank rows are skipped, and that ratings over five fail Pydantic validation. Mock the OpenAI client for analyzer unit tests, then run a small intentional smoke test with a real credential.

from models import RestaurantFinding
from pydantic import ValidationError
import pytest


def test_invalid_rating_is_rejected():
    with pytest.raises(ValidationError):
        RestaurantFinding(
            name="Example", sentiment="positive",
            rating_out_of_five=6,
            recommendation_reason="Unsupported rating range.",
        )

Schema validity is not factual validity. Review representative outputs for named-entity grounding, rating fidelity, correct sentiment, and unsupported details. Maintain a permissioned evaluation set when changing prompts, model configuration, schemas, or SDK versions. Avoid logging raw journal content by default because travel notes can contain personal data.

For GCC and Middle East deployments, apply the same data-handling discipline to Arabic and English input, local privacy obligations, data residency requirements, and organizational retention rules. This tutorial does not make claims about a particular regional provider, initiative, or infrastructure arrangement; teams should validate those requirements with their legal, security, and platform stakeholders before production use.

Next Steps

Store approved findings in SQLite and hash source entries to avoid repeated analysis.
Add a human review step before publishing recommendations.
Track input size, latency, failures, model configuration, and evaluation results without retaining unnecessary journal text.
Add explicit source excerpts to the schema if reviewers need faster fact verification.

The central lesson is simple: use typed contracts and controlled inputs to turn flexible model output into application data, then test both the software boundary and the factual usefulness of the result.

Integrating AI APIs with Advanced Libraries

Gate of AI — Wed, 22 Jul 2026 09:11:48 +0000

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

In this tutorial, we will integrate AI capabilities into your application using the latest API-driven interactions with powerful language models, focusing on real-time data processing and analysis.

Prerequisites

R version 4.2.0 or newer
Latest API client libraries installed
API key from a verified AI provider
Intermediate programming skills in R

What We're Building

This tutorial will guide you through creating a robust application that leverages modern API client libraries to interact with AI models. Our end goal is to build a system that can dynamically generate language-based outputs or embeddings, depending on user input or data streams.

The finished project will allow users to input text prompts, which the application will process to call the AI model's API. The model will return processed language data, which can be used for various applications like generating content, analyzing text, or creating data embeddings for further processing in machine learning pipelines.

Setup and Installation

To start, ensure that the latest API client libraries are correctly installed in your R environment, along with all necessary dependencies for API communication. This setup includes configuring environment variables to securely handle API keys.

install.packages("httr")

install.packages("dotenv")

Next, create a .env file in your project directory to store your API keys securely. This file should not be shared or included in version control.



API_KEY=your_api_key

Use the dotenv package to load these environment variables into your R session:

library(dotenv)

dotenv::load_dot_env()

Step 1: Setting Up API Communication

This step involves setting up a function to handle API requests to the AI model. We'll create a function that prepares the request, sends it, and processes the response.



library(httr)

send_api_request <- function(prompt, model_type = "gpt-4o") {

  api_key <- Sys.getenv("API_KEY")

  response <- POST(

    url = "https://api.example.com/v1/chat/completions",

    add_headers(Authorization = paste("Bearer", api_key)),

    body = list(

      model = model_type,

      messages = list(list(role = "user", content = prompt))

    ),

    encode = "json"

  )

stop_for_status(response)

  content(response, "parsed")

}

This function uses the httr package to send a POST request to the API with the user's prompt. It handles authorization by using the API key stored in environment variables and returns the parsed JSON response.

Step 2: Processing API Responses

Once we have the response from the API, we need to process it to extract the relevant information and present it in a user-friendly format.



process_response <- function(api_response) {

  choices <- api_response$choices

  if (length(choices) > 0) {

    return(choices[[1]]$message$content)

  } else {

    stop("No valid response from API")

  }

}

  
  
  Example usage


response <- send_api_request("Tell me a joke.")

joke <- process_response(response)

print(joke)

This code extracts the content of the message from the API's response. If the response contains valid data, it returns the text; otherwise, it raises an error.

Step 3: Integrating with Advanced Libraries

In this step, we will integrate our API communication functions with advanced libraries to leverage their capabilities for more sophisticated data handling and manipulation.



  
  
  Assuming a hypothetical advanced library for embeddings


library(AdvancedAI)

generate_embeddings <- function(text_input) {

  model_response <- send_api_request(text_input, model_type = "gpt-4o")

  processed_text <- process_response(model_response)

# Use AdvancedAI to generate embeddings

  embeddings <- AdvancedAI::generate_embeddings(processed_text)

  return(embeddings)

}

  
  
  Example usage


embedding_result <- generate_embeddings("Analyze this sentence for sentiment.")

print(embedding_result)

This function integrates the API request with advanced embedding generation capabilities, allowing us to convert processed text into embeddings for further analysis or machine learning applications.

⚠️ Common Mistake: Ensure that the API keys are correctly set in your environment. A common issue is not loading the .env file correctly, leading to failed authentication. Always verify your environment variables are loaded before making API requests.

Testing Your Implementation

To verify that your implementation works correctly, test the functions with various inputs and ensure the outputs are as expected. You can use the following code to do so:



test_prompt <- "What is the capital of France?"

response <- send_api_request(test_prompt)

print(process_response(response))

  
  
  Test embedding generation


embedding_test <- generate_embeddings("Test this embedding function.")

print(embedding_test)

When run, the first test should return "Paris" as the capital of France, and the second test should return a vector of embeddings indicating the function's success in processing the input.

What to Build Next

Extend the application to handle multi-turn conversations by maintaining a chat history.
Integrate sentiment analysis and topic modeling using advanced libraries and API responses for more enriched data insights.
Build a web interface using Shiny to allow non-technical users to interact with the AI-driven application easily.

Mastering AI Prompt Engineering in 2026

Gate of AI — Wed, 22 Jul 2026 09:11:34 +0000

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

Learn how to craft effective prompts for AI models to enhance performance and accuracy in various applications, with insights from the latest research.

Prerequisites

Python 3.10 or later
OpenAI and Anthropic API keys
Familiarity with AI model concepts and prompt engineering

What We're Building

In this comprehensive tutorial, we will delve into the art and science of prompt engineering for AI models using the latest techniques available in 2026. By the end of this tutorial, you'll be able to design prompts that yield highly accurate and contextually relevant responses from AI models like OpenAI's GPT-4o and Anthropic's Claude-3-5-sonnet-20241022.

The finished project will enable you to create tailored AI interactions that can be applied across various domains such as customer support, content generation, and data analysis, significantly improving model output quality and applicability.

Setup and Installation

To get started with prompt engineering, you need to set up your environment with the necessary tools and libraries. We'll be using Python as our primary language due to its rich ecosystem of AI and machine learning libraries.

pip install openai anthropic

Next, you need to configure your environment variables to securely store your API keys. This is crucial for authenticating requests to the AI services.



  
  
  .env file


OPENAI_API_KEY=your-openai-api-key

ANTHROPIC_API_KEY=your-anthropic-api-key

Step 1: Understanding Prompt Basics

Before diving into advanced techniques, it's essential to understand the basics of prompt engineering. A prompt is the input you provide to an AI model to guide its response. The quality of the prompt directly influences the model's output.



from openai import OpenAI

client = OpenAI(api_key='your-openai-api-key')

response = client.chat.completions.create(

    model="gpt-4o",

    messages=[

        {"role": "system", "content": "You are a helpful assistant."},

        {"role": "user", "content": "Can you summarize the key benefits of AI in healthcare?"}

    ]

)

print(response.choices[0].message['content'])

In this code, we initialize the OpenAI client and send a chat completion request. The system message sets the context, while the user message is the prompt. The model then generates a response based on these inputs.

Step 2: Implementing Few-shot Prompting

Few-shot prompting involves providing the AI model with examples of the input-output pair you expect. This technique helps the model understand the desired pattern and improves response accuracy.



from anthropic import Anthropic

client = Anthropic(api_key='your-anthropic-api-key')

response = client.messages.create(

    model="claude-3-5-sonnet-20241022",

    messages=[

        {"role": "system", "content": "You are an expert in financial markets."},

        {"role": "user", "content": "Here's an example of a market analysis: ..."},

        {"role": "user", "content": "Can you analyze the following market data: ..."}

    ]

)

print(response.choices[0].message['content'])

This example demonstrates how to provide the model with context and examples to guide its analysis of new data. The few-shot approach is particularly useful when the model needs to understand specific styles or formats.

Step 3: Utilizing Chain-of-Thought Prompting

Chain-of-thought prompting encourages the model to think through problems step by step, leading to more logical and comprehensive outputs. This technique is beneficial for complex problem-solving and reasoning tasks.



response = client.chat.completions.create(

    model="gpt-4o",

    messages=[

        {"role": "system", "content": "You are a problem-solving assistant."},

        {"role": "user", "content": "Explain the process of photosynthesis step by step."}

    ]

)

print(response.choices[0].message['content'])

Here, the model is prompted to break down the process of photosynthesis into logical steps, demonstrating its understanding of the topic while providing a clear, concise explanation.

⚠️ Common Mistake: Avoid using overly complex or ambiguous language in your prompts, as this can confuse the model and lead to inaccurate responses. Always aim for clarity and simplicity.

Testing Your Implementation

To ensure your prompts are effective, you should test them across various scenarios and inputs. This will help you refine your approach and improve the model's performance.



def test_prompt(prompt, expected_output):

    response = client.chat.completions.create(

        model="gpt-4o",

        messages=[

            {"role": "system", "content": "You are a helpful assistant."},

            {"role": "user", "content": prompt}

        ]

    )

    assert response.choices[0].message['content'] == expected_output, "Test failed!"

  
  
  Example test case


test_prompt("Summarize the benefits of AI in education.", "AI can personalize learning experiences, automate administrative tasks, and provide real-time analytics.")

This test function checks whether the model's output matches the expected result, allowing you to verify the effectiveness of your prompts.

What to Build Next

Develop a chatbot using advanced prompt engineering techniques for customer service.
Create a content generation tool that leverages few-shot and chain-of-thought prompting.
Integrate AI models into a data analysis platform to automate insights generation.

Build Conversational AI with OpenAI & Anthropic

Gate of AI — Tue, 14 Jul 2026 14:54:48 +0000

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

In this tutorial, we will build a robust conversational AI by integrating OpenAI, Anthropic, and Mistral APIs, showcasing their unique strengths in generating and managing conversations.

Prerequisites

Node.js v18 or later
API keys for OpenAI, Anthropic, and Mistral
Intermediate understanding of JavaScript and API integration

What We're Building

In this project, we will create a conversational AI application that leverages the latest advancements in AI models from OpenAI, Anthropic, and Mistral. Our application will be able to handle complex dialogues by dynamically selecting the best model for each user query based on predefined criteria such as context length, cost, and response type.

The final product will be a web-based chat interface where users can interact with our AI, which intelligently routes queries to the most suitable AI model. This setup not only demonstrates the capabilities of each API but also provides a flexible architecture that can be extended or modified to include additional models or features.

Setup and Installation

To get started, we need to set up our development environment. We'll use Node.js for our server-side logic and a simple HTML/CSS/JavaScript frontend to interact with our backend.

npm init -y

npm install express dotenv openai anthropic mistral

Next, we need to configure our environment variables to securely store our API keys. Create a .env file in the root of your project with the following content:

OPENAI_API_KEY=your_openai_api_key

ANTHROPIC_API_KEY=your_anthropic_api_key

MISTRAL_API_KEY=your_mistral_api_key

Step 1: Setting Up Express Server

We will first set up an Express server to handle HTTP requests from our frontend. This server will act as a middleman between our client-side application and the various AI APIs.

const express = require('express');

const dotenv = require('dotenv');

dotenv.config();

const app = express();

app.use(express.json());

const PORT = process.env.PORT || 3000;

app.listen(PORT, () => {

  console.log(Server is running on port ${PORT});

});

In this setup, we import the necessary modules and initialize our Express app. We also configure it to parse JSON payloads and listen on a specified port, which defaults to 3000 if not set in the environment variables.

Step 2: Integrating OpenAI API

Next, we'll integrate the OpenAI API. This API will handle general conversational tasks and provide responses based on user queries.

import { OpenAI } from 'openai';

const client = new OpenAI(process.env.OPENAI_API_KEY);

app.post('/api/openai', async (req, res) => {

  try {

    const { message } = req.body;

    const response = await client.chat.completions.create({

      model: "gpt-5.6",

      messages: [{ role: "user", content: message }],

    });

    res.json(response);

  } catch (error) {

    res.status(500).json({ error: error.message });

  }

});

This code sets up an endpoint to handle POST requests at /api/openai. It uses the OpenAI client to send a user message to the GPT-5.6 model and returns the response. Error handling is included to manage any issues that arise during the API request.

Step 3: Integrating Anthropic API

Now, we will integrate the Anthropic API, which is known for its safety and alignment capabilities, making it ideal for sensitive or ethical queries. Ensure to verify the latest API integration methods from Anthropic's official documentation.

// Placeholder for Anthropic API integration

// Verify with Anthropic's latest API documentation

Step 4: Integrating Mistral API

Finally, we'll integrate the Mistral API. Mistral models are designed for efficient handling of specialized tasks, making them a great choice for domain-specific queries. Verify the integration details with Mistral's latest API documentation.

// Placeholder for Mistral API integration

// Verify with Mistral's latest API documentation

⚠️ Common Mistake: Ensure that your API keys are correctly set in the .env file and that the environment variables are loaded properly. Forgetting to configure these can lead to authentication errors.

Testing Your Implementation

To verify that our setup is working correctly, we can use a tool like Postman to send POST requests to each of our API endpoints with a sample message. Ensure that each API responds with a valid completion and that errors are handled gracefully.

// Example POST request payload

{

  "message": "What is the weather like today?"

}

Send this payload to each endpoint and check the responses to ensure they're accurate and relevant to the input.

What to Build Next

Enhance the chat interface with real-time updates using WebSockets.
Implement a model selection algorithm to dynamically choose the best model based on query type.
Add user authentication to personalize and secure the chat experience.

GCC/Middle East Relevance

Integrating conversational AI systems aligns with regional initiatives like Saudi Vision 2030 and the UAE National Strategy for AI. These frameworks emphasize the importance of AI in transforming industries and enhancing digital infrastructure. Collaborations with local entities such as SDAIA and G42 can further enhance AI capabilities in the region.

Automate AI Workflows with OpenAI & Anthropic

Gate of AI — Tue, 14 Jul 2026 14:54:37 +0000

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

Learn how to automate complex AI workflows using the latest OpenAI and Anthropic APIs to enhance efficiency and scalability, with a focus on GCC/Middle East applications.

Prerequisites

Python 3.10 or later
OpenAI and Anthropic API keys
Advanced understanding of AI and API integrations

What We're Building

In this tutorial, we will create an automated AI workflow that leverages the capabilities of both OpenAI's latest models and Anthropic's Claude models. This project will demonstrate how to integrate multiple AI models to handle complex tasks such as natural language understanding, sentiment analysis, and data summarization.

The final application will automate data processing tasks, reducing manual intervention and enhancing accuracy and efficiency. It will serve as a robust foundation for integrating AI into business processes, enabling scalable and intelligent solutions, particularly in the GCC/Middle East region, aligning with initiatives like Saudi Vision 2030.

Setup and Installation

To begin, we need to set up our development environment. This involves installing the necessary Python packages and configuring environment variables for API keys.

pip install openai anthropic

Next, we need to set up our environment variables to securely store our API keys. Create a .env file in your project directory with the following content:

OPENAI_API_KEY=your_openai_api_key_here

ANTHROPIC_API_KEY=your_anthropic_api_key_here

Step 1: Integrating OpenAI API

In this step, we'll integrate the OpenAI API to handle tasks such as language generation and sentiment analysis. This integration will allow us to automate the process of interpreting and generating text-based data.

from openai import OpenAI

import os

from dotenv import load_dotenv

load_dotenv()

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def generate_text(prompt):

    response = client.chat.completions.create(

        model="gpt-4o",

        messages=[{"role": "system", "content": "You are an assistant."}, {"role": "user", "content": prompt}]

    )

    return response.choices[0].message.content

print(generate_text("Explain the benefits of AI automation."))

This code initializes the OpenAI client and defines a function generate_text that interacts with the GPT-4o model to generate responses based on the input prompt.

Step 2: Integrating Anthropic API

Next, we'll integrate the Anthropic API to utilize Claude's capabilities for tasks such as data summarization and context understanding. This will complement our OpenAI integration by providing additional AI functionalities.

from anthropic import Anthropic

anthropic_client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))

def summarize_text(text):

    response = anthropic_client.messages.create(

        model="claude-3-5-sonnet-20241022",

        prompt=f"Summarize the following text: {text}",

        max_tokens=150

    )

    return response.choices[0].text

print(summarize_text("OpenAI and Anthropic are leading AI research companies..."))

This segment of code sets up the Anthropic client and defines the summarize_text function, which requests a summary of the provided text from the Claude model.

Step 3: Automating Workflow Integration

In the final step, we will integrate both APIs into a unified workflow that automates the processing of data from input to output. This workflow will demonstrate the use of both models in a cohesive application.

def process_data(input_text):

    # Step 1: Generate contextual information using OpenAI

    context = generate_text(f"Provide context for: {input_text}")

# Step 2: Summarize the contextual information using Anthropic
summary = summarize_text(context)

return {
    "context": context,
    "summary": summary
}



input_data = "The impact of AI on modern industries is profound..."

result = process_data(input_data)

print("Context:", result["context"])

print("Summary:", result["summary"])

This function, process_data, orchestrates the workflow by generating context using OpenAI and summarizing it with Anthropic, thus providing a streamlined process for handling complex data tasks.

⚠️ Common Mistake: Ensure that your API keys are correctly set up in the environment variables. Misconfigured keys can lead to authentication errors that are difficult to debug.

Testing Your Implementation

To verify the workflow, run the script and check the output. You should see a detailed context and a concise summary of the input text, demonstrating the effective integration of both AI models.

# Command to run the script

python automate_workflow.py

What to Build Next

Extend the workflow to include more complex data processing tasks such as classification and anomaly detection.
Integrate a database to store and retrieve processed data efficiently.
Build a web interface to allow users to input data and receive AI-generated insights in real-time.

Build an AI Chatbot with OpenAI GPT-4o

Gate of AI — Tue, 14 Jul 2026 14:54:24 +0000

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

In this comprehensive tutorial, you will build a responsive AI chatbot using JavaScript and OpenAI's latest GPT-4o, enhancing user interaction through seamless AI integration.

Prerequisites

Node.js version 18 or higher
OpenAI API key
Intermediate JavaScript knowledge

What We're Building

This tutorial guides you through creating a dynamic AI-powered chatbot. The chatbot will leverage OpenAI's GPT-4o model for generating human-like responses, including recognizing emotional cues and engaging in rapid voice interactions. The end product will be a web-based chatbot capable of understanding and responding to user queries in a conversational manner.

The chatbot will be built using modern JavaScript practices, ensuring it is both efficient and easy to maintain. You'll learn how to set up the OpenAI client, handle asynchronous operations, and manage state effectively in a chat application context.

Setup and Installation

To get started, you will need to set up a Node.js environment and install the necessary packages. This includes the OpenAI SDK, which allows us to interact with the GPT-4o model.

npm install openai dotenv express

Next, configure your environment variables to securely store your OpenAI API key. Create a .env file in the root of your project directory.



OPENAI_API_KEY=your_openai_api_key_here

Step 1: Setting Up the Server

This step involves creating a simple Express server to handle HTTP requests. The server will act as the backend for our chatbot, interfacing with the OpenAI API.



const express = require('express');

const dotenv = require('dotenv');

const { OpenAI } = require('openai');

dotenv.config();

const app = express();

app.use(express.json());

const client = new OpenAI(process.env.OPENAI_API_KEY);

app.post('/api/chat', async (req, res) => {

  const { message } = req.body;

  try {

    const response = await client.chat.completions.create({

      model: "gpt-4o",

      messages: [{ role: "user", content: message }]

    });

    res.json({ reply: response.choices[0].message.content });

  } catch (error) {

    console.error(error);

    res.status(500).json({ error: 'Error processing request' });

  }

});

app.listen(3000, () => {

  console.log('Server is running on http://localhost:3000');

});

This code sets up an Express server that listens for POST requests on the /api/chat endpoint. It uses the OpenAI client to send the user message to the GPT-4o model and returns the AI's response.

Step 2: Creating the Frontend

In this step, you'll create a basic HTML page with a form for user input and an area to display the chatbot's responses.




AI Chatbot

body { font-family: Arial, sans-serif; }
#chat { max-width: 600px; margin: 20px auto; }
#messages { border: 1px solid #ccc; padding: 10px; height: 300px; overflow-y: scroll; }
#user-input { width: 100%; padding: 10px; }








document.getElementById('user-input').addEventListener('keydown', async function(e) {
  if (e.key === 'Enter') {
    const message = e.target.value;
    e.target.value = '';
    const messagesDiv = document.getElementById('messages');
    messagesDiv.innerHTML += `&lt;div&gt;&lt;strong&gt;You:&lt;/strong&gt; ${message}&lt;/div&gt;`;

    const response = await fetch('/api/chat', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ message })
    });
    const data = await response.json();
    messagesDiv.innerHTML += `&lt;div&gt;&lt;strong&gt;Bot:&lt;/strong&gt; ${data.reply}&lt;/div&gt;`;
    messagesDiv.scrollTop = messagesDiv.scrollHeight;
  }
});

This HTML page includes a simple chat interface. When the user presses Enter, the message is sent to the server, and the response is displayed in the chat window.

Step 3: Enhancing the Chat Experience

To improve user experience, we'll add features like loading indicators and error handling in the frontend.



const userInput = document.getElementById('user-input');

  const messagesDiv = document.getElementById('messages');

userInput.addEventListener('keydown', async function(e) {

    if (e.key === 'Enter') {

      const message = e.target.value;

      e.target.value = '';

      messagesDiv.innerHTML += &lt;div&gt;&lt;strong&gt;You:&lt;/strong&gt; ${message}&lt;/div&gt;;

      messagesDiv.innerHTML += &lt;div id="loading"&gt;Bot is typing...&lt;/div&gt;;

  try {
    const response = await fetch('/api/chat', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ message })
    });
    const data = await response.json();
    document.getElementById('loading').remove();
    messagesDiv.innerHTML += `&lt;div&gt;&lt;strong&gt;Bot:&lt;/strong&gt; ${data.reply}&lt;/div&gt;`;
  } catch (error) {
    document.getElementById('loading').remove();
    messagesDiv.innerHTML += `&lt;div&gt;&lt;strong&gt;Error:&lt;/strong&gt; Unable to fetch response&lt;/div&gt;`;
  }
  messagesDiv.scrollTop = messagesDiv.scrollHeight;
}



});

This script adds a "Bot is typing..." indicator while waiting for the response and handles any errors that occur during the fetch operation.

⚠️ Common Mistake: Ensure that the server is running and accessible from the frontend. Network errors can occur if the server is not active or if there are CORS issues.

Testing Your Implementation

To verify that your chatbot works, open the HTML file in a browser and try sending a few messages. You should see your input and the bot's responses in the chat window.



  
  
  Ensure your server is running


node server.js

  
  
  Open the HTML file in a browser and interact with the chatbot

What to Build Next

Add a database to store chat history and analyze user interactions.
Integrate speech recognition to allow voice input and output, aligning with the capabilities of GPT-4o.
Expand the chatbot's capabilities by integrating additional APIs for more diverse responses.

Incorporating AI technologies like GPT-4o can significantly enhance digital transformation initiatives in the GCC region, supporting goals such as Saudi Vision 2030 and the UAE's National Strategy for AI. By leveraging these advanced AI capabilities, businesses can improve customer engagement and operational efficiency.