DelphiGroqCloud
v1.0.0
Bienvenue dans l' emballage API GroqCloud non officiel pour Delphi . Ce projet fournit une interface Delphi pour accéder et interagir avec les modèles de langage puissants disponibles sur GroqCloud , y compris ceux développés par:
Meta Llama , OpenAI Whisper , MistralAI Mixtral et Google Gemma .
Avec cette bibliothèque, vous pouvez intégrer de manière transparente la génération de la langue, le chat et la vision de la génération de pointe, la génération de code ou la transcription de la parole dans vos applications Delphi .
Groqcloud propose une plate-forme efficace et efficace optimisée pour exécuter de grands modèles de langage via ses unités de traitement du langage propriétaires (LPU), offrant une vitesse et une efficacité énergétique qui dépassent les GPU traditionnels. Cet emballage simplifie l'accès à ces modèles, vous permettant de tirer parti de l'infrastructure de pointe de GroqCloud sans la surcharge de la gestion du matériel sous-jacent.
Pour plus de détails sur les offres de Groqcloud, visitez la documentation officielle de GroqCloud.
Pour initialiser l'instance API, vous devez obtenir une clé API à GroqCloud.
Une fois que vous avez un jeton, vous pouvez initialiser l'interface IGroq , qui est un point d'entrée à l'API.
En raison du fait qu'il peut y avoir de nombreux paramètres et tous ne sont pas nécessaires, ils sont configurés à l'aide d'une fonction anonyme.
Note
uses Groq;
var GroqCloud := TGroqFactory.CreateInstance(API_KEY);Avertissement
Pour utiliser les exemples fournis dans ce tutoriel, en particulier pour fonctionner avec des méthodes asynchrones, je recommande de définir l'interface GROQ avec la portée la plus large possible.
Donc, définissez GroqCloud := TGroqFactory.CreateInstance(API_KEY); dans l'événement OnCreate de votre demande.
Où GroqCloud: IGroq
Vous pouvez accéder à vos paramètres de compte GroqCloud pour afficher vos informations de paiement, votre utilisation, vos limites, vos journaux, vos équipes et votre profil en suivant ce lien.
Dans le contexte des méthodes asynchrones, pour une méthode qui n'implique pas de streaming, les rappels utilisent l'enregistrement générique suivant: TAsynCallBack<T> = record défini dans l'unité Gemini.Async.Support.pas . Cet enregistrement expose les propriétés suivantes:
TAsynCallBack<T> = record
...
Sender: TObject;
OnStart: TProc<TObject>;
OnSuccess: TProc<TObject, T>;
OnError: TProc<TObject, string>; Pour les méthodes nécessitant un streaming, les rappels utilisent l'enregistrement générique TAsynStreamCallBack<T> = record , également défini dans l'unité Gemini.Async.Support.pas . Cet enregistrement expose les propriétés suivantes:
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>;Le nom de chaque propriété est explicite; Si nécessaire, reportez-vous à la documentation interne pour plus de détails.
GroqCloud prend actuellement en charge les modèles suivants.
Les modèles hébergés sont accessibles directement via le point de terminaison de l'API des modèles GroqCloud en utilisant les ID du modèle répertoriés ci-dessus. Pour récupérer une liste JSON de tous les modèles disponibles, utilisez le point de terminaison à 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 ne fournit aucune solutions pour l'intégration de texte.
L' API Groq Chat Completion interprète une série de messages et produit des sorties de réponse correspondantes. Ces modèles peuvent gérer des conversations multi-tours ou des tâches à interaction unique.
Le mode JSON du mode JSON (BETA) est actuellement en version bêta et garantit que toutes les compléments de chat sont au format JSON valide.
Comment utiliser:
"response_format": {"type": "json_object"} Dans votre demande de complétion de chat. Meilleures pratiques pour les performances bêta optimales:
Limitations bêta:
Code d'erreur:
Si la génération JSON échoue, Groq répondra avec une erreur de 400 , spécifiant json_validate_failed comme code d'erreur.
Note
Nous n'utiliserons que des méta-modèles dans tous les exemples fournis pour la génération de texte.
L'API GroqCloud permet la génération de texte en utilisant diverses entrées, comme le texte et les images. Il est polyvalent et peut prendre en charge un large éventail d'applications, notamment:
Dans les exemples ci-dessous, nous utiliserons les procédures Display pour simplifier les choses.
Conseil
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 ); Dans les exemples ci-dessous, nous utiliserons les procédures Display pour simplifier les choses.
Conseil
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 ); Vous pouvez utiliser l'API GroqCloud pour créer des expériences de chat interactives personnalisées pour vos utilisateurs. Avec la capacité de chat de l'API, vous pouvez faciliter plusieurs séries de questions et réponses, permettant aux utilisateurs de travailler progressivement vers leurs solutions ou d'obtenir une prise en charge de problèmes complexes et en plusieurs étapes. Cette fonctionnalité est particulièrement précieuse pour les applications qui nécessitent une interaction continue, comme:
Voici un échantillon asynchrounly d'une configuration 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 ); Lors de la configuration d'un modèle d'IA, vous avez la possibilité de définir des directives sur la façon dont il doit réagir. Par exemple, vous pouvez lui attribuer un rôle particulier, comme act as a mathematician ou lui donner des instructions sur le ton, comme peak like a military instructor . Ces directives sont établies en configurant les instructions du système lorsque le modèle est initialisé.
Les instructions système vous permettent de personnaliser le comportement du modèle en fonction des besoins spécifiques et des cas d'utilisation. Une fois configurés, ils ajoutent un contexte qui aide à guider le modèle pour effectuer des tâches plus précisément en fonction des directives prédéfinies tout au long de l'interaction. Ces instructions s'appliquent à plusieurs interactions avec le modèle.
Les instructions du système peuvent être utilisées à plusieurs fins, telles que:
Ces instructions peuvent être définies lors de l'initialisation du modèle et resteront actives pour la durée de la session, guidant comment le modèle réagit. Ils font partie intégrante des invites du modèle et respectent les politiques d'utilisation des données standard.
// 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 );Prudence
Les instructions du système aident le modèle à suivre les instructions, mais ils n'empêchent pas complètement le jailbreaks ou les fuites d'informations. Nous vous conseillons d'utiliser la prudence lors de l'ajout d'informations sensibles à ces instructions.
Chaque invite envoyée au modèle est livrée avec des paramètres qui déterminent comment les réponses sont générées. Vous avez la possibilité d'ajuster ces paramètres, vous permettant de réprimer divers paramètres. Si aucune configuration personnalisée n'est appliquée, le modèle utilisera ses paramètres par défaut, ce qui peut varier en fonction du modèle spécifique.
Voici un exemple montrant comment modifier plusieurs de ces options.
// 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 );L'API GROQ fournit une inférence rapide et une faible latence pour les modèles multimodaux avec des capacités de vision, permettant la compréhension et l'interprétation des données visuelles des images. En examinant le contenu d'une image, ces modèles multimodaux peuvent produire du texte lisible par l'homme pour offrir des informations précieuses sur les informations visuelles fournies.
L'API GROQ permet des modèles multimodaux avancés qui s'intègrent en douceur dans diverses applications, offrant des capacités de traitement d'image efficaces et précises pour des tâches telles que la réponse à la question visuelle, la génération de légendes et la reconnaissance des caractères optiques (OCR).
Voir la documentation officielle.
Les types de mime d'image pris en charge incluent les formats suivants:
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 );Les modèles LLAMA-3.2-90B-Vision-Preview et Llama-3.2-11b-Vision-Preview prennent désormais en charge le mode JSON! Voici un exemple de Python qui interroge le modèle avec une image et un texte (par exemple, "Veuillez extraire les informations pertinentes en tant qu'objet JSON.") Avec Response_Format réglé sur le mode JSON.
Prudence
AVERTISSEMENT, vous ne pouvez pas utiliser le mode JSON avec une réponse en difficulté.
// 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 );Bien que vous puissiez ajouter plusieurs images, GroqCloud limite ses modèles de vision à une seule image. En conséquence, il n'est pas possible de comparer plusieurs images.
L'API GROQ fournit une solution de discours à texte très efficace, offrant des points de terminaison compatibles OpenAI qui facilitent la transcription et la traduction en temps réel. Cette API fournit une intégration transparente pour les capacités avancées de traitement audio dans les applications, réalisant des vitesses comparables à la conversation humaine en temps réel.
L'API levient les modèles de chuchotements d'Openai, ainsi que le modèle à étreinte distil-whisper-large-v3-en sur le visage étreint (anglais uniquement). Pour plus de détails, veuillez vous référer à la documentation officielle.
Les téléchargements de fichiers sont actuellement limités à 25 Mo et les types de fichiers d'entrée suivants sont pris en charge:
mp3mp4mpegmpgam4awavwebm Conseil
procedure Display (Sender: TObject; Transcription: TAudioText); overload;
begin
Display(Sender, Transcription.Text);
end ;De manière asynchrone
// 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 texte facultatif pour guider le style du modèle ou continuer un segment audio précédent. L' prompt doit correspondre à la langue audio.
Reportez-vous à la documentation officielle pour des paramètres détaillés.
De manière asynchrone
// 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 vous incluez un paramètre prompt dans votre demande, il doit être écrit en anglais.
Reportez-vous à la documentation officielle pour des paramètres détaillés.
L'intégration de l'utilisation des outils permet aux modèles de langue importants (LLM) d'interfacer avec des ressources externes comme les API, les bases de données et le Web, permettant l'accès aux données en direct et prolonger leurs capacités au-delà de la génération de texte. Cette fonctionnalité comble l'écart entre les connaissances statiques de la formation LLM et la nécessité d'informations dynamiques actuelles, ouvrant la voie à des applications qui dépendent des données en temps réel et des informations exploitables. Couplé aux vitesses d'inférence rapide de Groq, l'utilisation des outils débloque le potentiel d'applications à haute performance en temps réel dans diverses industries.
Reportez-vous à la documentation officielle
GROQ a affiné les modèles suivants spécifiquement pour une utilisation optimisée d'outils, et ils sont maintenant disponibles dans l'aperçu public:
llama3-groq-70b-8192-tool-use-previewllama3-groq-8b-8192-tool-use-previewPour plus de détails, veuillez consulter l'annonce de lancement.
Avertissement
Pour les cas d'utilisation des outils multi-tours étendus, nous suggérons de tirer parti des capacités d'utilisation de l'outil natif des Llama 3.1 models . Pour les scénarios plus étroits et multi-tours, les modèles d'utilisation d'outils affinés peuvent être plus efficaces. Nous vous recommandons d'expérimenter les deux approches pour déterminer lesquelles convient le mieux à votre cas d'utilisation spécifique.
Les Llama-3.1 models suivants sont également fortement recommandés pour les applications d'outils en raison de leur polyvalence et de leurs performances solides:
llama-3.1-70b-versatilellama-3.1-8b-instantAutres modèles pris en charge
Les modèles suivants alimentés par GROQ prennent également en charge l'utilisation de l'outil:
llama3-70b-8192llama3-8b-8192mixtral-8x7b-32768 (utilisation de l'outil parallèle non pris en charge)gemma-7b-it (Utilisation d'outils parallèles non pris en charge)gemma2-9b-it (Utilisation d'outils parallèles non pris en charge)Conseil
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 ;Dans cet exemple de code, si l'outil renvoie plusieurs résultats, seuls les deux premiers seront traités et affichés dans chacun des deux TMEMO, respectivement.
L'unité Groq.Functions.Core.pas fournit les classes et méthodes nécessaires pour développer des plugins d'outils. Chaque plugin hérite de la classe TFunctionCore , qui met en œuvre les méthodes définies par l'interface IFunctionCore . Pour obtenir des conseils sur la création de fonctions personnalisées, reportez-vous à l'unité Groq.Functions.Example.pas , qui sert d'exemple pratique.
GroqCloud donne accès au modèle de modèle Llama-Guard-3-8B pour une modération efficace de contenu de texte.
Exemple de code de modération
Conseil
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 ); L'unité Groq.Safety.pas fournit des frameworks et des outils pour catégoriser et gérer un contenu nocif basé sur des catégories de préjudice prédéfinies. Il comprend des énumérations, des méthodes d'assistance et des enregistrements pour rationaliser l'identification et la classification de divers types de préjudice dans les applications, soutenant une approche structurée de la sécurité du contenu et de l'évaluation des risques.
Note
Llama Guard 3 est formé pour prédire les étiquettes de sécurité sur les 14 catégories ci-dessous, sur la base de la taxonomie MLCommons des dangers.
Groqcloud ne propose actuellement pas d'options pour affiner les modèles disponibles.
Conseil
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);
...Les demandes de traction sont les bienvenues. Si vous prévoyez d'apporter un changement majeur, veuillez d'abord ouvrir un problème pour discuter de vos modifications proposées.
Ce projet est autorisé sous la licence du MIT.
