Comment intégrer Azure OpenAI Service en 2026

#!/bin/bash

# Installer Azure CLI si pas présent (macOS/Linux)
curl -sL https://aka.ms/InstallAzureCLIDeb | sudo bash

# Login interactif
az login

# Définir subscription par défaut (remplacez YOUR_SUB_ID)
# az account list --output table
az account set --subscription "YOUR_SUBSCRIPTION_ID"

# Vérifier
az account show --query name -o tsv

#!/bin/bash

RESOURCE_GROUP="learni-openai-rg"
LOCATION="francecentral"
RESOURCE_NAME="learni-openai-$(date +%s)"

# Créer groupe de ressources
az group create --name $RESOURCE_GROUP --location $LOCATION

# Créer ressource OpenAI (S0 pour prod, quota 1000 RPM)
az cognitiveservices account create \
  --name $RESOURCE_NAME \
  --resource-group $RESOURCE_GROUP \
  --kind OpenAI \
  --sku S0 \
  --location $LOCATION

# Récupérer endpoint et clé
ENDPOINT=$(az cognitiveservices account show --name $RESOURCE_NAME --resource-group $RESOURCE_GROUP --query properties.endpoint -o tsv)
KEY=$(az cognitiveservices account keys list --name $RESOURCE_NAME --resource-group $RESOURCE_GROUP --query key1 -o tsv)

echo "Endpoint: $ENDPOINT"
echo "Key: $KEY"

# Déployer GPT-4o-mini (économique, rapide)
az cognitiveservices account deployment create \
  --name $RESOURCE_NAME \
  --resource-group $RESOURCE_GROUP \
  --deployment-name gpt-4o-mini \
  --model-name gpt-4o-mini \
  --model-version 2024-07-18 \
  --model-format ChatCompletion \
  --sku-capacity 1

#!/bin/bash

mkdir azure-openai-app && cd azure-openai-app
npm init -y
npm install @azure/openai dotenv typescript @types/node ts-node
npm install -D @types/node

cat > .env << EOF
AZURE_OPENAI_ENDPOINT=https://YOUR_RESOURCE.openai.azure.com/
AZURE_OPENAI_KEY=your_key_here
AZURE_OPENAI_DEPLOYMENT=gpt-4o-mini
EOF

cat > tsconfig.json << 'EOF'
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "strict": true,
    "esModuleInterop": true
  }
}
EOF

import { AzureOpenAI } from '@azure/openai';
import dotenv from 'dotenv';

dotenv.config();

const client = new AzureOpenAI({
  endpoint: process.env.AZURE_OPENAI_ENDPOINT!,
  apiKey: process.env.AZURE_OPENAI_KEY!,
  apiVersion: '2024-10-21',
});

async function chatBasic() {
  const response = await client.getChatCompletions(
    process.env.AZURE_OPENAI_DEPLOYMENT!,
    [
      { role: 'system', content: 'Tu es un expert Azure.' },
      { role: 'user', content: 'Explique tool calling en 3 points.' },
    ],
    {
      temperature: 0.7,
      maxTokens: 500,
    }
  );

  console.log(response.choice[0]?.message?.content);
}

chatBasic().catch(console.error);

import { AzureOpenAI } from '@azure/openai';
import dotenv from 'dotenv';

dotenv.config();

const client = new AzureOpenAI({
  endpoint: process.env.AZURE_OPENAI_ENDPOINT!,
  apiKey: process.env.AZURE_OPENAI_KEY!,
  apiVersion: '2024-10-21',
});

// Tool exemple: fonction météo mock
const tools = [
  {
    type: 'function',
    function: {
      name: 'get_weather',
      description: 'Obtenir la météo pour une ville',
      parameters: {
        type: 'object',
        properties: {
          city: { type: 'string' },
        },
        required: ['city'],
      },
    },
  },
];

function getWeather(city: string): string {
  return `Météo à ${city}: 22°C, ensoleillé.`;
}

async function chatStreamTools() {
  const stream = await client.getChatCompletionsStream(
    process.env.AZURE_OPENAI_DEPLOYMENT!,
    [{ role: 'user', content: 'Quelle est la météo à Paris ?' }],
    { tools, temperature: 0 }
  );

  let toolCalls: any[] = [];
  for await (const event of stream) {
    const delta = event.choice[0]?.delta;
    if (delta?.toolCalls) {
      toolCalls.push(...delta.toolCalls);
    } else if (delta?.content) {
      process.stdout.write(delta.content);
    }
  }

  // Exécuter tools si appelés
  for (const toolCall of toolCalls) {
    if (toolCall.function.name === 'get_weather') {
      const args = JSON.parse(toolCall.function.arguments);
      const result = getWeather(args.city);
      console.log(`\nRésultat tool: ${result}`);
    }
  }
}

chatStreamTools().catch(console.error);

#!/bin/bash

RESOURCE_GROUP="learni-openai-rg"
SEARCH_NAME="learni-search-$(date +%s)"
LOCATION="francecentral"

# Créer AI Search (Basic pour test)
az search service create --name $SEARCH_NAME --resource-group $RESOURCE_GROUP --sku Basic --location $LOCATION

SEARCH_ENDPOINT=$(az search service show --name $SEARCH_NAME --resource-group $RESOURCE_GROUP --query "hostingConfiguration.publicNetworkAccess" -o tsv | grep -o 'https[^ ]*')
SEARCH_KEY=$(az search admin-key show --service-name $SEARCH_NAME --resource-group $RESOURCE_GROUP --query primaryKey -o tsv)

echo "Search Endpoint: $SEARCH_ENDPOINT"
echo "Search Key: $SEARCH_KEY"

# Ajouter à .env
cat >> .env << EOF
AZURE_SEARCH_ENDPOINT=$SEARCH_ENDPOINT
AZURE_SEARCH_KEY=$SEARCH_KEY
EOF

import { AzureOpenAI } from '@azure/openai';
import dotenv from 'dotenv';
import { SearchClient, AzureKeyCredential, VectorizedSearchOptions } from '@azure/search-documents';

dotenv.config();

const openai = new AzureOpenAI({
  endpoint: process.env.AZURE_OPENAI_ENDPOINT!,
  apiKey: process.env.AZURE_OPENAI_KEY!,
  apiVersion: '2024-10-21',
});

const searchClient = new SearchClient(
  process.env.AZURE_SEARCH_ENDPOINT! + '/indexes/rag-index',
  'contentVector',
  new AzureKeyCredential(process.env.AZURE_SEARCH_KEY!)
);

async function generateEmbeddings(text: string) {
  const emb = await openai.getEmbeddings('text-embedding-3-small', [{ input: text }]);
  return emb.embedding?.[0];
}

async function ragQuery(query: string) {
  const queryEmb = await generateEmbeddings(query);

  const searchOptions: VectorizedSearchOptions = {
    vectorQueries: [{ kind: 'vector', vector: queryEmb!, k: 3, fields: 'contentVector' }],
  };

  const results = await searchClient.search('*', searchOptions);
  console.log('Top docs:', results.results.map(r => r.document));

  // RAG: chat avec context
  const context = results.results.map(r => r.document.pageContent).join('\n');
  const chatResponse = await openai.getChatCompletions(
    process.env.AZURE_OPENAI_DEPLOYMENT!,
    [
      { role: 'system', content: 'Réponds basé sur ce contexte:' },
      { role: 'user', content: `${query}\nContexte: ${context}` },
    ]
  );
  console.log(chatResponse.choice[0]?.message?.content);
}

ragQuery('Quels sont les prérequis Azure OpenAI ?').catch(console.error);