DelphiGroqCloud
v1.0.0
Bem -vindo ao invólucro não oficial da API GroqCloud para Delphi . Este projeto fornece uma interface Delphi para acessar e interagir com os poderosos modelos de idiomas disponíveis no Groqcloud , incluindo os desenvolvidos por:
Meta Llama , OpenAI Whisper , MistralAI Mixtral e Google Gemma .
Com esta biblioteca, você pode integrar perfeitamente a geração de idiomas de última geração, recursos de bate-papo e visão, geração de código ou transcrição de fala para texto em seus aplicativos Delphi .
A GroqCloud oferece uma plataforma de alto desempenho e eficiente otimizada para executar grandes modelos de linguagem por meio de suas unidades proprietárias de processamento de idiomas (LPUs), fornecendo velocidade e eficiência energética que superam as GPUs tradicionais. Esse invólucro simplifica o acesso a esses modelos, permitindo que você aproveite a infraestrutura de ponta do Groqcloud sem a sobrecarga de gerenciar o hardware subjacente.
Para mais detalhes sobre as ofertas do Groqcloud, visite a documentação oficial do GroqCloud.
Para inicializar a instância da API, você precisa obter uma chave da API no GroqCloud.
Depois de ter um token, você pode inicializar a interface IGroq , que é um ponto de entrada para a API.
Devido ao fato de que podem haver muitos parâmetros e nem todos eles são necessários, eles são configurados usando uma função anônima.
Observação
uses Groq;
var GroqCloud := TGroqFactory.CreateInstance(API_KEY);Aviso
Para usar os exemplos fornecidos neste tutorial, especialmente para trabalhar com métodos assíncronos, recomendo definir a interface Groq com o escopo mais amplo possível.
Então, set GroqCloud := TGroqFactory.CreateInstance(API_KEY); No evento OnCreate do seu aplicativo.
Onde GroqCloud: IGroq
Você pode acessar as configurações da conta GroqCloud para visualizar suas informações de pagamento, uso, limites, logs, equipes e perfil seguindo este link.
No contexto de métodos assíncronos, para um método que não envolve streaming, os retornos de chamada usam o seguinte registro genérico: TAsynCallBack<T> = record definido na unidade Gemini.Async.Support.pas . Este registro expõe as seguintes propriedades:
TAsynCallBack<T> = record
...
Sender: TObject;
OnStart: TProc<TObject>;
OnSuccess: TProc<TObject, T>;
OnError: TProc<TObject, string>; Para métodos que requerem streaming, os retornos de chamada usam o registro genérico TAsynStreamCallBack<T> = record , também definido na unidade Gemini.Async.Support.pas . Este registro expõe as seguintes propriedades:
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>;O nome de cada propriedade é auto-explicativo; Se necessário, consulte a documentação interna para obter mais detalhes.
Atualmente, o GroqCloud suporta os seguintes modelos.
Os modelos hospedados podem ser acessados diretamente através do ponto de extremidade da API dos modelos GroqCloud usando os IDs do modelo listados acima. Para recuperar uma lista JSON de todos os modelos disponíveis, use o terminal em 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 );O GroqCloud não fornece nenhuma solução para integração de texto.
A API de conclusão do Groq Chat interpreta uma série de mensagens e produz saídas de resposta correspondentes. Esses modelos podem lidar com conversas com várias turnos ou tarefas de interação única.
O modo JSON JSON (BETA) JSON está atualmente na versão beta e garante que todas as conclusões do bate -papo estejam no formato JSON válido.
Como usar:
"response_format": {"type": "json_object"} na sua solicitação de conclusão de bate -papo. Melhores práticas para desempenho beta ideal:
Limitações beta:
Código de erro:
Se a geração JSON falhar, Groq responderá com um erro 400 , especificando json_validate_failed como o código de erro.
Observação
Usaremos apenas meta -modelos em todos os exemplos fornecidos para geração de texto.
A API GroqCloud permite geração de texto usando várias entradas, como texto e imagens. É versátil e pode suportar uma ampla variedade de aplicativos, incluindo:
Nos exemplos abaixo, usaremos os procedimentos Display para simplificar as coisas.
Dica
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 ); Nos exemplos abaixo, usaremos os procedimentos Display para simplificar as coisas.
Dica
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 ); Você pode utilizar a API GroqCloud para criar experiências de bate -papo interativas personalizadas para seus usuários. Com a capacidade de bate-papo da API, você pode facilitar várias rodadas de perguntas e respostas, permitindo que os usuários trabalhem gradualmente em direção às suas soluções ou obtenham suporte para problemas complexos e de várias etapas. Esse recurso é particularmente valioso para aplicativos que precisam de interação contínua, como:
Aqui está uma amostra assíncrona de uma configuração simples de bate -papo:
// 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 ); Ao configurar um modelo de IA, você tem a opção de definir diretrizes de como ele deve responder. Por exemplo, você pode atribuir um papel específico, como act as a mathematician ou dar instruções sobre tom, como peak like a military instructor . Essas diretrizes são estabelecidas configurando instruções do sistema quando o modelo é inicializado.
As instruções do sistema permitem que você personalize o comportamento do modelo para atender às necessidades e casos de uso específicos. Uma vez configurados, eles adicionam contexto que ajuda a orientar o modelo para executar tarefas com mais precisão, de acordo com as diretrizes predefinidas durante toda a interação. Essas instruções se aplicam em várias interações com o modelo.
As instruções do sistema podem ser usadas para vários propósitos, como:
Essas instruções podem ser definidas durante a inicialização do modelo e permanecerão ativas durante a duração da sessão, orientando como o modelo responde. Eles são parte integrante dos avisos do modelo e aderem às políticas de uso de dados padrão.
// 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 );Cuidado
As instruções do sistema ajudam o modelo a seguir as instruções, mas elas não impedem completamente jailbreaks ou vazamentos de informações. Aconselhamos usar cautela ao adicionar qualquer informação confidencial a essas instruções.
Cada prompt enviado ao modelo vem com configurações que determinam como as respostas são geradas. Você tem a opção de ajustar essas configurações, permitindo ajustar vários parâmetros. Se nenhuma configuração personalizada for aplicada, o modelo usará suas configurações padrão, que podem variar dependendo do modelo específico.
Aqui está um exemplo mostrando como modificar várias dessas opções.
// 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 );A API Groq fornece rápida inferência e baixa latência para modelos multimodais com recursos de visão, permitindo a compreensão e interpretação dos dados visuais das imagens. Ao examinar o conteúdo de uma imagem, esses modelos multimodais podem produzir texto legível pelo homem para oferecer informações valiosas sobre as informações visuais fornecidas.
A API GROQ permite modelos multimodais avançados que se integrem suavemente em diversas aplicações, fornecendo recursos de processamento de imagem eficientes e precisos para tarefas como resposta visual de perguntas, geração de legenda e reconhecimento de caracteres ópticos (OCR).
Veja a documentação oficial.
Os tipos de mímica de imagem suportados incluem os seguintes 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 );Os modelos LLAMA-3.2-90B-VISION-PREVISTA e LLAMA-3.2-11B-VISION-PREVIEW agora suportam o modo JSON! Aqui está um exemplo python que consulta o modelo com uma imagem e texto (por exemplo, "Extrair informações relevantes como um objeto JSON.") Com resposta_format definido como modo json.
Cuidado
Aviso, você não pode usar o modo JSON com uma resposta 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 );Embora você possa adicionar várias imagens, o GroqCloud limita seus modelos de visão a uma única imagem. Como resultado, não é possível comparar várias imagens.
A API Groq fornece uma solução de fala para texto altamente eficiente, oferecendo pontos de extremidade compatíveis com o OpenAI que facilitam a transcrição e a tradução em tempo real. Esta API fornece integração perfeita para recursos avançados de processamento de áudio em aplicativos, atingindo velocidades comparáveis à conversa humana em tempo real.
As APIs aproveitam os modelos Whisper da OpenAI, juntamente com o modelo distante distil-whisper-large-v3-en disponível no rosto de abraço (somente em inglês). Para mais detalhes, consulte a documentação oficial.
Atualmente, os uploads de arquivo estão limitados a 25 MB e os seguintes tipos de arquivo de entrada são suportados:
mp3mp4mpegmpgam4awavwebm Dica
procedure Display (Sender: TObject; Transcription: TAudioText); overload;
begin
Display(Sender, Transcription.Text);
end ;Assíncrono
// 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 ); Um texto opcional para orientar o estilo do modelo ou continuar um segmento de áudio anterior. O prompt deve corresponder ao idioma de áudio.
Consulte a documentação oficial para obter parâmetros detalhados.
Assíncrono
// 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 ); Se você incluir um parâmetro prompt em sua solicitação, ele deve ser escrito em inglês.
Consulte a documentação oficial para obter parâmetros detalhados.
A integração do uso de ferramentas permite que grandes modelos de linguagem (LLMS) interajam com recursos externos, como APIs, bancos de dados e a Web, permitindo o acesso a dados ao vivo e estendendo seus recursos além da geração de texto. Essa funcionalidade preenche a lacuna entre o conhecimento estático do treinamento LLM e a necessidade de informações dinâmicas atuais, abrindo caminho para aplicativos que dependem de dados em tempo real e informações acionáveis. Juntamente com as rápidas velocidades de inferência do GROQ, o uso de ferramentas desbloqueia o potencial de aplicações de alto desempenho e em tempo real em diversas indústrias.
Consulte a documentação oficial
A GROQ ajustou os seguintes modelos especificamente para uso de ferramentas otimizado e agora estão disponíveis na visualização pública:
llama3-groq-70b-8192-tool-use-previewllama3-groq-8b-8192-tool-use-previewPara mais detalhes, consulte o anúncio do lançamento.
Aviso
Para casos de uso de ferramentas extensos e de várias turnos, sugerimos alavancar os recursos de uso da ferramenta nativa dos Llama 3.1 models . Para cenários mais estreitos e de várias turnos, os modelos de uso de ferramentas ajustados podem ser mais eficazes. Recomendamos experimentar ambas as abordagens para determinar quais é melhor se adequar ao seu caso de uso específico.
Os seguintes Llama-3.1 models também são altamente recomendados para aplicações de ferramentas devido à sua versatilidade e forte desempenho:
llama-3.1-70b-versatilellama-3.1-8b-instantOutros modelos suportados
Os seguintes modelos alimentados pelo GROQ também suportam o uso da ferramenta:
llama3-70b-8192llama3-8b-8192mixtral-8x7b-32768 (uso paralelo de ferramenta não suportado)gemma-7b-it (uso de ferramenta paralelo não suportado)gemma2-9b-it (uso de ferramenta paralelo não suportado)Dica
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 ;Neste exemplo de código, se a ferramenta retornar vários resultados, apenas os dois primeiros serão processados e exibidos em cada um dos dois tmemo, respectivamente.
A unidade Groq.Functions.Core.pas fornece as classes e métodos necessários para o desenvolvimento de plugins de ferramentas. Cada plug -in herda da classe TFunctionCore , que implementa os métodos definidos pela interface IFunctionCore . Para obter orientações sobre a criação de funções personalizadas, consulte a unidade Groq.Functions.Example.pas , que serve como um exemplo prático.
O GroqCloud fornece acesso ao modelo de modelo Llama-Guard-3-8B para moderação eficaz de conteúdo de texto.
Exemplo de código de moderação
Dica
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 ); A unidade Groq.Safety.pas fornece estruturas e ferramentas para categorizar e gerenciar conteúdo nocivo com base em categorias de danos predefinidos. Inclui enumerações, métodos auxiliares e registros para otimizar a identificação e classificação de vários tipos de danos nas aplicações, apoiando uma abordagem estruturada para a segurança do conteúdo e a avaliação de riscos.
Observação
Llama Guard 3 é treinada para prever os rótulos de segurança nas 14 categorias mostradas abaixo, com base na taxonomia dos riscos da MLCommons.
Atualmente, o GroqCloud não fornece opções para ajustar os modelos disponíveis.
Dica
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);
...Solicitações de tração são bem -vindas. Se você planeja fazer uma grande mudança, abra um problema primeiro para discutir suas alterações propostas.
Este projeto está licenciado sob a licença do MIT.
