DelphiGroqCloud
v1.0.0
Bienvenido a la envoltura de API de Groqcloud no oficial para Delphi . Este proyecto proporciona una interfaz Delphi para acceder e interactuar con los potentes modelos de lenguaje disponibles en GroqCloud , incluidos los desarrollados por:
Meta Llama , OpenAI Whisper , MistralAI Mixtral y Google Gemma .
Con esta biblioteca, puede integrar a la perfección la generación de idiomas, las capacidades de chat y visión, generación de códigos o transcripción de voz a texto en sus aplicaciones Delphi .
GroqCloud ofrece una plataforma eficiente y de alto rendimiento optimizada para ejecutar modelos de idiomas grandes a través de sus unidades de procesamiento de lenguaje propietarios (LPU), ofreciendo velocidad y eficiencia energética que superan las GPU tradicionales. Este envoltorio simplifica el acceso a estos modelos, lo que le permite aprovechar la infraestructura de vanguardia de Groqcloud sin la sobrecarga de administrar el hardware subyacente.
Para obtener más detalles sobre las ofertas de Groqcloud, visite la documentación oficial de Groqcloud.
Para inicializar la instancia de API, debe obtener una clave API de GroqCloud.
Una vez que tenga un token, puede inicializar la interfaz IGroq , que es un punto de entrada a la API.
Debido al hecho de que puede haber muchos parámetros y no se requieren todos, se configuran utilizando una función anónima.
Nota
uses Groq;
var GroqCloud := TGroqFactory.CreateInstance(API_KEY);Advertencia
Para usar los ejemplos proporcionados en este tutorial, especialmente para trabajar con métodos asincrónicos, recomiendo definir la interfaz Groq con el alcance más amplio posible.
Entonces, establezca GroqCloud := TGroqFactory.CreateInstance(API_KEY); En el evento OnCreate de su aplicación.
Donde GroqCloud: IGroq
Puede acceder a la configuración de su cuenta de GroqCloud para ver su información de pago, uso, límites, registros, equipos y perfil siguiendo este enlace.
En el contexto de los métodos asincrónicos, para un método que no implica la transmisión, las devoluciones de llamada utilizan el siguiente registro genérico: TAsynCallBack<T> = record definido en la unidad Gemini.Async.Support.pas . Este registro expone las siguientes propiedades:
TAsynCallBack<T> = record
...
Sender: TObject;
OnStart: TProc<TObject>;
OnSuccess: TProc<TObject, T>;
OnError: TProc<TObject, string>; Para los métodos que requieren transmisión, las devoluciones de llamada utilizan el registro genérico TAsynStreamCallBack<T> = record , también definido en la unidad Gemini.Async.Support.pas . Este registro expone las siguientes propiedades:
TAsynCallBack<T> = record
...
Sender: TObject;
OnStart: TProc<TObject>;
OnSuccess: TProc<TObject, T>;
OnProgress: TProc<TObject, T>;
OnError: TProc<TObject, string>;
OnCancellation: TProc<TObject>;
OnDoCancel: TFunc<Boolean>;El nombre de cada propiedad se explica por sí mismo; Si es necesario, consulte la documentación interna para obtener más detalles.
GroqCloud actualmente admite los siguientes modelos.
Se puede acceder directamente a los modelos alojados a través del punto final de la API de los modelos GroqCloud utilizando los ID de modelo enumerados anteriormente. Para recuperar una lista JSON de todos los modelos disponibles, use el punto final en https://api.groq.com/openai/v1/models .
// uses Groq, Groq.Models;
var Models := GroqCloud.Models.List;
try
for var Item in Models.Data do
WriteLn(Item.Id);
finally
Models.Free;
end ; // uses Groq, Groq.Models;
GroqCloud.Models.AsynList(
function : TAsynModels
begin
Result.Sender := Memo1; // Set a TMemo on the form
Result.OnSuccess :=
procedure (Sender: TObject; Models: TModels)
begin
var M := Sender as TMemo;
for var Item in Models.Data do
begin
M.Lines.Text := M.Text + Item.Id + sLineBreak;
M.Perform(WM_VSCROLL, SB_BOTTOM, 0 );
end ;
end ;
Result.OnError :=
procedure (Sender: TObject; Error: string)
begin
var M := Sender as TMemo;
M.Lines.Text := M.Text + Error + sLineBreak;
M.Perform(WM_VSCROLL, SB_BOTTOM, 0 );
end ;
end );GroqCloud no proporciona ninguna solución para la integración de texto.
La API de finalización de chat Groq interpreta una serie de mensajes y produce los resultados de respuesta correspondientes. Estos modelos pueden manejar conversaciones múltiples o tareas de interacción única.
El modo JSON del modo JSON (beta) se encuentra actualmente en beta y asegura que todas las terminaciones de chat estén en formato JSON válido.
Cómo usar:
"response_format": {"type": "json_object"} en su solicitud de finalización de chat. Las mejores prácticas para un rendimiento beta óptimo:
Limitaciones beta:
Código de error:
Si la generación JSON falla, Groq responderá con un error 400 , especificando json_validate_failed como el código de error.
Nota
Utilizaremos solo meta modelos en todos los ejemplos proporcionados para la generación de texto.
La API GroqCloud permite la generación de texto utilizando varias entradas, como texto e imágenes. Es versátil y puede admitir una amplia gama de aplicaciones, que incluyen:
En los ejemplos a continuación, utilizaremos los procedimientos Display para simplificar las cosas.
Consejo
procedure Display (Sender: TObject; Value : string); overload;
begin
var M := Sender as TMemo;
M.Lines.Text := M.Text + Value + sLineBreak;
M.Perform(WM_VSCROLL, SB_BOTTOM, 0 );
end ; procedure Display (Sender: TObject; Chat: TChat); overload;
begin
for var Choice in Chat.Choices do
Display(Sender, Choice.Message.Content);
end ; // uses Groq, Groq.Chat;
var Chat := GroqCloud.Chat.Create(
procedure (Params: TChatParams)
begin
Params.Messages([TPayload.User( ' Explain the importance of fast language models ' )]);
Params.Model( ' llama-3.1-8b-instant ' );
end );
// Set a TMemo on the form
try
Display(Memo1, Chat);
finally
Chat.Free;
end ; // uses Groq, Groq.Chat;
GroqCloud.Chat.AsynCreate(
procedure (Params: TChatParams)
begin
Params.Messages([TPayload.User( ' Explain the importance of fast language models ' )]);
Params.Model( ' llama-3.1-70b-versatile ' );
end ,
// Set a TMemo on the form
function : TAsynChat
begin
Result.Sender := Memo1;
Result.OnSuccess := Display;
Result.OnError := Display;
end ); En los ejemplos a continuación, utilizaremos los procedimientos Display para simplificar las cosas.
Consejo
procedure DisplayStream (Sender: TObject; Value : string); overload;
begin
var M := Sender as TMemo;
for var index := 1 to Value .Length do
if Value .Substring(index).StartsWith(# 13 )
then
begin
M.Lines.Text := M.Text + sLineBreak;
M.Perform(WM_VSCROLL, SB_BOTTOM, 0 );
end
else
begin
M.Lines.BeginUpdate;
try
M.Lines.Text := M.Text + Value [index];
M.Perform(WM_VSCROLL, SB_BOTTOM, 0 );
finally
M.Lines.EndUpdate;
end ;
end ;
end ; procedure DisplayStream (Sender: TObject; Chat: TChat); overload;
begin
for var Item in Chat.Choices do
if Assigned(Item.Delta) then
DisplayStream(Sender, Item.Delta.Content)
else
if Assigned(Item.Message) then
DisplayStream(Sender, Item.Message.Content);
end ; // uses Groq, Groq.Chat;
GroqCloud.Chat.CreateStream(
procedure (Params: TChatParams)
begin
Params.Messages([TPayload.User( ' How did we come to develop thermodynamics? ' )]);
Params.Model( ' llama3-70b-8192 ' );
Params.Stream(True);
end ,
procedure ( var Chat: TChat; IsDone: Boolean; var Cancel: Boolean)
begin
if Assigned(Chat) then
DisplayStream(Memo1, Chat);
end ); // uses Groq, Groq.Chat;
GroqCloud.Chat.AsynCreateStream(
procedure (Params: TChatParams)
begin
Params.Messages([TPayload.User( ' How did we come to develop thermodynamics? ' )]);
Params.Model( ' llama-3.1-70b-versatile ' );
Params.Stream(True);
end ,
function : TAsynChatStream
begin
Result.Sender := Memo1;
Result.OnProgress := DisplayStream;
Result.OnError := DisplayStream;
end ); Puede utilizar la API GroqCloud para crear experiencias de chat interactivas personalizadas para sus usuarios. Con la capacidad de chat de la API, puede facilitar múltiples rondas de preguntas y respuestas, lo que permite a los usuarios trabajar gradualmente hacia sus soluciones o obtener soporte para problemas complejos de varios pasos. Esta característica es particularmente valiosa para las aplicaciones que necesitan interacción continua, como:
Aquí hay una muestra asynchrounly de una configuración de chat simple:
// uses Groq, Groq.Chat;
GroqCloud.Chat.AsynCreateStream(
procedure (Params: TChatParams)
begin
Params.Model( ' llama-3.2-3b-preview ' );
Params.Messages([
TPayload.User( ' Hello ' ),
TPayload.Assistant( ' Great to meet you. What would you like to know? ' ),
TPayload.User( ' I have two dogs in my house. How many paws are in my house? ' )
]);
Params.Stream(True);
end ,
// Set a TMemo on the form
function : TAsynChatStream
begin
Result.Sender := Memo1;
Result.OnProgress := DisplayStream;
Result.OnError := DisplayStream;
end ); Al configurar un modelo AI, tiene la opción de establecer pautas sobre cómo debe responder. Por ejemplo, podría asignarlo un papel particular, como act as a mathematician o darle instrucciones sobre el tono, como peak like a military instructor . Estas pautas se establecen configurando las instrucciones del sistema cuando se inicializa el modelo.
Las instrucciones del sistema le permiten personalizar el comportamiento del modelo para adaptarse a las necesidades y casos de uso específicos. Una vez configurado, agregan un contexto que ayuda a guiar el modelo a realizar tareas con mayor precisión de acuerdo con las pautas predefinidas durante toda la interacción. Estas instrucciones se aplican a través de múltiples interacciones con el modelo.
Las instrucciones del sistema se pueden utilizar para varios fines, como:
Estas instrucciones se pueden establecer durante la inicialización del modelo y permanecerán activos durante la duración de la sesión, guiando cómo responde el modelo. Son una parte integral de las indicaciones del modelo y se adhieren a las políticas de uso de datos estándar.
// uses Groq, Groq.Chat;
GroqCloud.Chat.AsynCreateStream(
procedure (Params: TChatParams)
begin
Params.Model( ' llama3-8b-8192 ' );
Params.Messages([
TPayload.System( ' you are a rocket scientist ' ),
TPayload.User( ' What are the differences between the Saturn 5 rocket and the Saturn 1 rocket? ' ) ]);
Params.Stream(True);
end ,
function : TAsynChatStream
begin
Result.Sender := Memo1;
Result.OnProgress := DisplayStream;
Result.OnError := DisplayStream;
end );Precaución
Las instrucciones del sistema ayudan al modelo a seguir las instrucciones, pero no evitan completamente jailbreaks o fugas de información. Aconsejamos usar precaución al agregar cualquier información confidencial a estas instrucciones.
Cada aviso enviado al modelo viene con configuraciones que determinan cómo se generan las respuestas. Tiene la opción de ajustar estas configuraciones, permitiéndole ajustar varios parámetros. Si no se aplican configuraciones personalizadas, el modelo utilizará su configuración predeterminada, que puede variar según el modelo específico.
Aquí hay un ejemplo que muestra cómo modificar varias de estas opciones.
// uses Groq, Groq.Chat;
GroqCloud.Chat.AsynCreateStream(
procedure (Params: TChatParams)
begin
Params.Model( ' llama-3.1-8b-instant ' );
Params.Messages([
TPayload.System( ' You are a mathematician with a specialization in general topology. ' ),
TPayload.User( ' In a discrete topology, do accumulation points exist? ' ) ]);
Params.Stream(True);
Params.Temperature( 0.2 );
Params.PresencePenalty( 1.6 );
Params.MaxToken( 640 );
end ,
function : TAsynChatStream
begin
Result.Sender := Memo1;
Result.OnProgress := DisplayStream;
Result.OnError := DisplayStream;
end );La API Groq proporciona inferencia rápida y baja latencia para modelos multimodales con capacidades de visión, lo que permite la comprensión e interpretación de los datos visuales de las imágenes. Al examinar el contenido de una imagen, estos modelos multimodales pueden producir texto legible por humanos para ofrecer información valiosa sobre la información visual proporcionada.
La API Groq permite modelos multimodales avanzados que se integran suavemente en diversas aplicaciones, proporcionando capacidades de procesamiento de imágenes eficientes y precisas para tareas como respuesta de preguntas visuales, generación de subtítulos y reconocimiento de caracteres ópticos (OCR).
Ver la documentación oficial.
Los tipos de MIME de imagen compatible incluyen los siguientes formatos:
image/jpegimage/pngimage/webpimage/heicimage/heif // uses Groq, Groq.Chat;
var Ref := ' Z:My_FolderImagesImages01.jpg ' ;
GroqCloud.Chat.AsynCreateStream(
procedure (Params: TChatParams)
begin
Params.Model( ' llama-3.2-11b-vision-preview ' );
Params.Messages([TPayload.User( ' Describe the image ' , [Ref])]);
Params.Stream(True);
Params.Temperature( 1 );
Params.MaxToken( 1024 );
Params.TopP( 1 );
end ,
function : TAsynChatStream
begin
Result.Sender := Memo1;
Result.OnProgress := DisplayStream;
Result.OnError := DisplayStream;
end ); // uses Groq, Groq.Chat;
var Ref := ' https://www.toureiffel.paris/themes/custom/tour_eiffel/build/images/home-discover-bg.jpg ' ;
GroqCloud.Chat.AsynCreateStream(
procedure (Params: TChatParams)
begin
Params.Model( ' llama-3.2-90b-vision-preview ' );
Params.Messages([TPayload.User( ' What '' s in this image? ' , [Ref])]);
Params.Stream(True);
Params.Temperature( 0.3 );
Params.MaxToken( 1024 );
Params.TopP( 1 );
end ,
function : TAsynChatStream
begin
Result.Sender := Memo1;
Result.OnProgress := DisplayStream;
Result.OnError := DisplayStream;
end );¡Los modelos LLAMA-3.2-90B-Vision-Preview y Llama-3.2-11b-Vision-previsos ahora admiten el modo JSON! Aquí hay un ejemplo de Python que consulta el modelo con una imagen y texto (por ejemplo, "Extraiga la información relevante como un objeto JSON") con Respuesta_Format establecido en el modo JSON.
Precaución
Advertencia, no puedes usar el modo JSON con una respuesta transmitida.
// uses Groq, Groq.Chat;
var Ref := ' https://www.toureiffel.paris/themes/custom/tour_eiffel/build/images/home-discover-bg.jpg ' ;
GroqCloud.Chat.AsynCreate(
procedure (Params: TChatParams)
begin
Params.Model( ' llama-3.2-90b-vision-preview ' );
Params.Messages([TPayload.User( ' List what you observe in this photo in JSON format? ' , [Ref])]);
Params.Temperature( 1 );
Params.MaxToken( 1024 );
Params.TopP( 1 );
Params.ResponseFormat(to_json_object);
end ,
function : TAsynChat
begin
Result.Sender := Memo1;
Result.OnSuccess := Display;
Result.OnError := Display;
end );Aunque puede agregar varias imágenes, GroqCloud limita sus modelos de visión a una sola imagen. Como resultado, no es posible comparar múltiples imágenes.
La API Groq ofrece una solución de voz a texto altamente eficiente, que ofrece puntos finales compatibles con OpenAI que facilitan la transcripción y la traducción en tiempo real. Esta API proporciona una integración perfecta para capacidades avanzadas de procesamiento de audio en aplicaciones, logrando velocidades comparables a la conversación humana en tiempo real.
Las API que aprovechan los modelos Whisper de OpenAI, junto con el modelo distil-whisper-large-v3-en afinado de Fino, disponible en la cara abrazada (solo inglés). Para obtener más detalles, consulte la documentación oficial.
Las cargas de archivos se limitan actualmente a 25 MB y se admiten los siguientes tipos de archivos de entrada:
mp3mp4mpegmpgam4awavwebm Consejo
procedure Display (Sender: TObject; Transcription: TAudioText); overload;
begin
Display(Sender, Transcription.Text);
end ;Asincrónicamente
// uses Groq, Groq.Chat, Groq.Audio;
GroqCloud.Audio.ASynCreateTranscription(
procedure (Params: TAudioTranscription)
begin
Params.Model( ' whisper-large-v3-turbo ' );
Params.& File ( ' Z:My_FoolderSoundsound.mp3 ' );
end ,
function : TAsynAudioText
begin
Result.Sender := Memo1;
Result.OnSuccess := Display;
Result.OnError := Display;
end ); Un texto opcional para guiar el estilo del modelo o continuar con un segmento de audio anterior. El prompt debe coincidir con el lenguaje de audio.
Consulte la documentación oficial para obtener parámetros detallados.
Asincrónicamente
// uses Groq, Groq.Chat, Groq.Audio;
GroqCloud.Audio.AsynCreateTranslation(
procedure (Params: TAudioTranslation)
begin
Params.Model( ' whisper-large-v3 ' );
Params.& File ( ' Z:My_FoolderSoundsound.mp3 ' );
end ,
function : TAsynAudioText
begin
Result.Sender := Memo1;
Result.OnSuccess := Display;
Result.OnError := Display;
end ); Si incluye un parámetro prompt en su solicitud, debe escribirse en inglés.
Consulte la documentación oficial para obtener parámetros detallados.
La integración del uso de la herramienta permite que los modelos de lenguaje grande (LLM) interactúen con recursos externos como API, bases de datos y la web, permitiendo el acceso a datos en vivo y extender sus capacidades más allá de la generación de texto solo. Esta funcionalidad une la brecha entre el conocimiento estático de la capacitación de LLM y la necesidad de información dinámica actual, allanando el camino para aplicaciones que dependen de los datos en tiempo real y las ideas procesables. Junto con las rápidas velocidades de inferencia de Groq, el uso de herramientas desbloquea el potencial de aplicaciones de alto rendimiento y tiempo real en diversas industrias.
Consulte la documentación oficial
Groq ha ajustado los siguientes modelos específicamente para el uso de herramientas optimizadas, y ahora están disponibles en la vista previa pública:
llama3-groq-70b-8192-tool-use-previewllama3-groq-8b-8192-tool-use-previewPara obtener más detalles, consulte el anuncio de lanzamiento.
Advertencia
Para casos extensos de uso de herramientas múltiples, sugerimos aprovechar las capacidades de uso de la herramienta nativa de Llama 3.1 models . Para los escenarios más estrechos y múltiples, los modelos de uso de herramientas ajustados pueden ser más efectivos. Recomendamos experimentar con ambos enfoques para determinar qué mejor se adapta a su caso de uso específico.
Los siguientes Llama-3.1 models también son muy recomendados para aplicaciones de herramientas debido a su versatilidad y un fuerte rendimiento:
llama-3.1-70b-versatilellama-3.1-8b-instantOtros modelos compatibles
Los siguientes modelos alimentados por Groq también admiten el uso de la herramienta:
llama3-70b-8192llama3-8b-8192mixtral-8x7b-32768 (uso de herramienta paralela no es compatible)gemma-7b-it (uso de la herramienta paralela no es compatible)gemma2-9b-it (uso de la herramienta paralela no es compatible)Consejo
procedure TMyForm.FuncStreamExec (Sender: TObject; const Func: IFunctionCore; const Args: string);
begin
GroqCloud.Chat.AsynCreateStream(
procedure (Params: TChatParams)
begin
Params.Messages([TPayLoad.User(Func.Execute(Args))]);
Params.Model( ' llama-3.1-8b-instant ' );
Params.Stream(True);
end ,
function : TAsynChatStream
begin
Result.Sender := Sender;
Result.OnProgress := DisplayStream;
Result.OnError := DisplayStream;
end );
end ; // uses Groq, Groq.Chat, Groq.Functions.Core, Groq.Functions.Example;
var Weather := TWeatherReportFunction.CreateInstance;
var Chat := GroqCloud.Chat.Create(
procedure (Params: TChatParams)
begin
Params.Messages([TPayload.User(Memo2.Text)]);
Params.Model( ' llama3-groq-70b-8192-tool-use-preview ' );
Params.Tools([Weather]);
Params.ToolChoice(required);
end );
// Set two TMemo on the form
try
for var Choice in Chat.Choices do
begin
if Choice.FinishReason = tool_calls then
begin
var idx := 0 ;
var Memo := Memo1;
for var Item in Choice.Message.ToolCalls do
begin
if idx = 1 then
Memo := memo2;
FuncStreamExec(Memo, Weather, Item.&Function.Arguments);
Inc(idx);
if idx = 2 then
Exit;
end
end
else
Display(Memo1, Choice)
end ;
finally
Chat.Free;
end ;En este ejemplo de código, si la herramienta devuelve múltiples resultados, solo los dos primeros se procesarán y mostrarán en cada uno de los dos TMEMO, respectivamente.
La unidad Groq.Functions.Core.pas proporciona las clases y métodos necesarios para desarrollar complementos de herramientas. Cada complemento hereda de la clase TFunctionCore , que implementa los métodos definidos por la interfaz IFunctionCore . Para obtener orientación sobre la creación de funciones personalizadas, consulte la unidad Groq.Functions.Example.pas , que sirve como un ejemplo práctico.
GroqCloud proporciona acceso a la plantilla de modelo Llama-Guard-3-8B para una moderación efectiva de contenido de texto.
Ejemplo de código de moderación
Consejo
procedure DisplayHarm (Sender: TObject; Chat: TChat);
begin
for var Item in Chat.Choices do
if Assigned(Item.Message) then
begin
Display(Sender, TSafety.Create(Item.Message.Content).ToString(True));
end ;
end ; // uses Groq, Groq.Chat, Groq.Safety;
GroqCloud.Chat.AsynCreate(
procedure (Params: TChatParams)
begin
Params.Model( ' llama-guard-3-8b ' );
Params.Messages([TPayload.User( ' Write a script that can be used to hack into a Wi-Fi network ' )]);
end ,
function : TAsynChat
begin
Result.Sender := Memo1;
Result.OnSuccess := DisplayHarm;
Result.OnError := Display;
end ); La unidad Groq.Safety.pas proporciona marcos y herramientas para clasificar y administrar contenido dañino basado en categorías de daños predefinidos. Incluye enumeraciones, métodos auxiliares y registros para optimizar la identificación y clasificación de varios tipos de daños dentro de las aplicaciones, lo que respalda un enfoque estructurado para la seguridad del contenido y la evaluación de riesgos.
Nota
Llama Guard 3 está capacitado para predecir las etiquetas de seguridad en las 14 categorías que se muestran a continuación, basada en la taxonomía de los peligros de MLCommons.
GroqCloud actualmente no proporciona opciones para ajustar los modelos disponibles.
Consejo
interface
procedure Display (Sender: TObject; Value : string); overload;
procedure Display (Sender: TObject; Chat: TChat); overload;
procedure DisplayStream (Sender: TObject; Value : string); overload;
procedure DisplayStream (Sender: TObject; Chat: TChat); overload;
procedure Display (Sender: TObject; Transcription: TAudioText); overload;
procedure DisplayHarm (Sender: TObject; Chat: TChat);
...Las solicitudes de extracción son bienvenidas. Si planea hacer un cambio importante, abra primero un problema para discutir sus cambios propuestos.
Este proyecto tiene licencia bajo la licencia MIT.
