Análisis Profundo del Llamado de Funciones de OpenAI: Principios, Aplicaciones y Práctica

1244Palabras
6Minutos
28 Jun, 2024
- IA

La funcionalidad de Llamado de Funciones de OpenAI es una herramienta poderosa que permite a los desarrolladores invocar funciones predefinidas a través de lenguaje natural. Este artículo presentará detalladamente esta funcionalidad desde las perspectivas de qué, por qué y cómo, y proporcionará ejemplos de casos de uso y explicaciones.

¿Qué es Function Calling?

Definición

Function Calling es una funcionalidad de la API de OpenAI que permite a los desarrolladores invocar funciones predefinidas mediante instrucciones en lenguaje natural. De este modo, podemos encapsular operaciones complejas en funciones y luego invocarlas mediante simples comandos en lenguaje natural.

Principios de Funcionamiento

La funcionalidad de Function Calling se basa en la capacidad del modelo de OpenAI para comprender el lenguaje natural. Los desarrolladores definen un conjunto de funciones y proporcionan descripciones de estas al modelo. Cuando el usuario proporciona una instrucción en lenguaje natural, el modelo analiza la instrucción y llama a la función correspondiente.

¿Por qué usar Function Calling?

Simplificar Operaciones Complejas

Function Calling permite encapsular operaciones complejas en llamadas a funciones simples, de modo que los usuarios no necesitan conocer los detalles de la implementación subyacente. Por ejemplo, podemos definir una función para consultar una base de datos y luego invocar esa función mediante una instrucción en lenguaje natural.

Mejorar la Eficiencia del Desarrollo

Con Function Calling, los desarrolladores pueden construir y expandir aplicaciones más rápidamente. Solo necesitamos definir las funciones y sus descripciones, dejando el resto del trabajo al modelo de OpenAI.

Mejorar la Experiencia del Usuario

Function Calling permite a los usuarios interactuar con aplicaciones mediante lenguaje natural, ofreciendo una experiencia de usuario más intuitiva y amigable. Esto es especialmente útil en la creación de chatbots, asistentes virtuales y aplicaciones similares.

¿Cómo usar Function Calling?

Definir Funciones

Primero, necesitamos definir las funciones que queremos invocar y proporcionar una descripción para cada una. Estas descripciones ayudarán al modelo a entender el propósito y los parámetros de las funciones.

1
export function getWeather(location) {
2
  // Supongamos que esta es una función para consultar el clima
3
  return `El clima en ${location} es soleado.`;
4
}
5

6
export function getNews(topic) {
7
  // Supongamos que esta es una función para consultar noticias
8
  return `Aquí están las últimas noticias sobre ${topic}.`;
9
}

Configurar la Solicitud API

En la solicitud API, necesitamos proporcionar las descripciones de las funciones y la entrada del usuario. El modelo llamará a la función correspondiente según la entrada del usuario.

1
import { OpenAI } from "openai";
2
import { getWeather, getNews } from "./functions";
3

4
// Configurar la API de OpenAI
5
const openai = new OpenAI({
6
  apiKey: process.env.OPENAI_API_KEY,
7
});
8

9
// Definir el mapeo de funciones
10
const functions = {
11
  getWeather,
12
  getNews,
13
};
14

15
// Configurar el modelo
16
async function callOpenAIFunction(prompt) {
17
  const response = await openai.chat.completions.create({
18
    model: "gpt-4-0613", // Usar el modelo compatible con Function Calling
19
    messages: [
20
      { role: "system", content: "Eres un asistente útil." },
21
      { role: "user", content: prompt },
22
    ],
23
    functions: [
24
      {
25
        name: "getWeather",
26
        description: "Obtener el clima actual para una ubicación dada.",
27
        parameters: {
28
          type: "object",
29
          properties: {
30
            location: {
31
              type: "string",
32
              description: "El nombre de la ubicación para obtener el clima.",
33
            },
34
          },
35
          required: ["location"],
36
        },
37
      },
38
      {
39
        name: "getNews",
40
        description: "Obtener las últimas noticias sobre un tema dado.",
41
        parameters: {
42
          type: "object",
43
          properties: {
44
            topic: {
45
              type: "string",
46
              description: "El tema sobre el cual obtener noticias.",
47
            },
48
          },
49
          required: ["topic"],
50
        },
51
      },
52
    ],
53
  });
54

55
  const message = response.choices[0].message;
56

57
  if (message.tool_calls) {
58
    for (const tool_call of message.tool_calls) {
59
      const functionName = tool_call.function.name;
60
      const functionToCall = functions[functionName];
61
      const functionArgs = JSON.parse(tool_call.function.arguments);
62
      const functionResult = functionToCall(...Object.values(functionArgs));
63

64
      console.log(
65
        `Función ${functionName} llamada con resultado: ${functionResult}`,
66
      );
67
    }
68
  } else {
69
    console.log(`Respuesta del modelo: ${message.content}`);
70
  }
71
}
72

73
// Ejemplos de llamadas
74
callOpenAIFunction("Obtener el clima en Nueva York.");
75
callOpenAIFunction("Obtener las últimas noticias sobre tecnología.");

Casos de Uso

Escenario 1: Control de Hogar Inteligente

En un sistema de hogar inteligente, podemos definir funciones para controlar varios dispositivos y luego controlarlos mediante comandos en lenguaje natural.

1
export function turnOnLight(room) {
2
  return `Encendiendo la luz en el ${room}.`;
3
}
4

5
export function setThermostat(temperature) {
6
  return `Estableciendo el termostato a ${temperature} grados.`;
7
}
8

9
// Configurar la API de OpenAI
10
const openai = new OpenAI({
11
  apiKey: process.env.OPENAI_API_KEY,
12
});
13

14
// Definir el mapeo de funciones
15
const functions = {
16
  turnOnLight,
17
  setThermostat,
18
};
19

20
// Configurar el modelo
21
async function callOpenAIFunction(prompt) {
22
  const response = await openai.chat.completions.create({
23
    model: "gpt-4-0613", // Usar el modelo compatible con Function Calling
24
    messages: [
25
      { role: "system", content: "Eres un asistente útil." },
26
      { role: "user", content: prompt },
27
    ],
28
    functions: [
29
      {
30
        name: "turnOnLight",
31
        description: "Encender la luz en una habitación específica.",
32
        parameters: {
33
          type: "object",
34
          properties: {
35
            room: {
36
              type: "string",
37
              description: "El nombre de la habitación para encender la luz.",
38
            },
39
          },
40
          required: ["room"],
41
        },
42
      },
43
      {
44
        name: "setThermostat",
45
        description: "Establecer el termostato a una temperatura específica.",
46
        parameters: {
47
          type: "object",
48
          properties: {
49
            temperature: {
50
              type: "number",
51
              description: "La temperatura para establecer el termostato.",
52
            },
53
          },
54
          required: ["temperature"],
55
        },
56
      },
57
    ],
58
  });
59

60
  const message = response.choices[0].message;
61

62
  if (message.tool_calls) {
63
    for (const tool_call of message.tool_calls) {
64
      const functionName = tool_call.function.name;
65
      const functionToCall = functions[functionName];
66
      const functionArgs = JSON.parse(tool_call.function.arguments);
67
      const functionResult = functionToCall(...Object.values(functionArgs));
68

69
      console.log(
70
        `Función ${functionName} llamada con resultado: ${functionResult}`,
71
      );
72
    }
73
  } else {
74
    console.log(`Respuesta del modelo: ${message.content}`);
75
  }
76
}
77

78
// Ejemplos de llamadas
79
callOpenAIFunction("Enciende la luz en la sala de estar.");
80
callOpenAIFunction("Establece el termostato a 22 grados.");

Escenario 2: Atención al Cliente

En un sistema de atención al cliente, podemos definir funciones para manejar problemas comunes y luego invocarlas mediante comandos en lenguaje natural.

1
export function checkOrderStatus(orderId) {
2
  return `El pedido ${orderId} está en proceso.`;
3
}
4

5
export function cancelOrder(orderId) {
6
  return `El pedido ${orderId} ha sido cancelado.`;
7
}
8

9
// Configurar la API de OpenAI
10
const openai = new OpenAI({
11
  apiKey: process.env.OPENAI_API_KEY,
12
});
13

14
// Definir el mapeo de funciones
15
const functions = {
16
  checkOrderStatus,
17
  cancelOrder,
18
};
19

20
// Configurar el modelo
21
async function callOpenAIFunction(prompt) {
22
  const response = await openai.chat.completions.create({
23
    model: "gpt-4-0613", // Usar el modelo compatible con Function Calling
24
    messages: [
25
      { role: "system", content: "Eres un asistente útil." },
26
      { role: "user", content: prompt },
27
    ],
28
    functions: [
29
      {
30
        name: "checkOrderStatus",
31
        description: "Consultar el estado de un pedido.",
32
        parameters: {
33
          type: "object",
34
          properties: {
35
            orderId: {
36
              type: "string",
37
              description: "El ID del pedido a consultar.",
38
            },
39
          },
40
          required: ["orderId"],
41
        },
42
      },
43
      {
44
        name: "cancelOrder",
45
        description: "Cancelar un pedido.",
46
        parameters: {
47
          type: "object",
48
          properties: {
49
            orderId: {
50
              type: "string",
51
              description: "El ID del pedido a cancelar.",
52
            },
53
          },
54
          required: ["orderId"],
55
        },
56
      },
57
    ],
58
  });
59

60
  const message = response.choices[0].message;
61

62
  if (message.tool_calls) {
63
    for (const tool_call of message.tool_calls) {
64
      const functionName = tool_call.function.name;
65
      const functionToCall = functions[functionName];
66
      const functionArgs = JSON.parse(tool_call.function.arguments);
67
      const functionResult = functionToCall(...Object.values(functionArgs));
68

69
      console.log(
70
        `Función ${functionName} llamada con resultado: ${functionResult}`,
71
      );
72
    }
73
  } else {
74
    console.log(`Respuesta del modelo: ${message.content}`);
75
  }
76
}
77

78
// Ejemplos de llamadas
79
callOpenAIFunction("Consultar el estado del pedido 12345.");
80
callOpenAIFunction("Cancelar el pedido 12345.");

Mejores Prácticas

Descripciones Claras de Funciones: Asegúrate de que cada función tenga una descripción clara y precisa para que el modelo pueda comprender exactamente el propósito y los parámetros de la función.
Manejo Adecuado de Errores: En aplicaciones reales, asegúrate de manejar adecuadamente los posibles errores, como fallos en la llamada a funciones o parámetros incorrectos.
Optimización Continua: Mejora continuamente las funciones y descripciones basándote en los comentarios de los usuarios y el uso real para mejorar la precisión del modelo y la experiencia del usuario.

Conclusión

La funcionalidad de Function Calling de OpenAI simplifica las operaciones complejas, mejora la eficiencia del desarrollo y enriquece la experiencia del usuario al combinar instrucciones en lenguaje natural con funciones predefinidas. Ya sea en hogares inteligentes, atención al cliente u otros escenarios, Function Calling puede proporcionar un soporte poderoso.