phenomenal ai

? Ai fenomenal

A IA fenomenal é um pacote digital para criar um gerador de prompt de conversação baseado em turnos para grandes modelos de idiomas. Este pacote fornece os blocos de construção para simular interações de conversação entre várias entidades, chamadas de atores. Os atores podem compartilhar informações, se envolver no diálogo e ajustar dinamicamente o curso da conversa com base em regras predefinidas.

? Características

• Abstração de alto nível : a IA fenomenal fornece um alto nível de abstração para modelos de conversação baseados em IA. Isso permite que você se concentre na lógica da conversa e não no modelo subjacente.
• ? Vários atores : este pacote suporta interação entre vários atores, permitindo cenários de conversação complexos. Cada ator pode ter sua própria personalidade e preferências.
• Histórico de conversas : toda conversa tem uma história que rastreia o curso do diálogo ao longo do tempo. A história é usada para gerar respostas a novas linhas de diálogo.
• ? Contexto compartilhado : os atores em uma conversa compartilham um contexto que lhes permite armazenar e recuperar informações relevantes para a discussão em andamento. O contexto pode ser usado para armazenar informações como o tópico da conversa, a localização, a hora do dia etc.
• Agendamento : o pacote fornece um mecanismo para decidir a ordem de reviravoltas entre os atores usando os agendadores. O pacote vem com um agendador padrão que os agendos giram de maneira redonda.
• ? Gerenciamento de transformação de conversação : controla o fluxo de virada da conversa e fornece um método para injetar novas mensagens na conversa. O pacote também fornece um método para consultar a conversa com uma pergunta e obter uma resposta.
• Gerenciamento de janelas de contexto : o pacote fornece um mecanismo para gerenciar a janela de contexto. A janela de contexto é o número de tokens para desmascarar a história ao gerar uma resposta. Isso permite controlar o tamanho rápido e a quantidade de contexto fornecida ao modelo.
• ? Leve : o pacote possui apenas uma dependência externa ( mustache ), tornando -o leve e fácil de usar.
• ? Extensível : o pacote foi projetado para ser extensível. Você pode fornecer sua própria função de geração de texto, agendador etc.

? Começando

Você pode instalar o pacote via npm :

npm install @wecandobetter/phenomenal-ai

Ou via Yarn:

yarn add @wecandobetter/phenomenal-ai

Exemplos de uso

A classe de Conversation encapsula todos os atores e gerencia a história, o contexto e a programação das voltas do ator. A classe Actor representa um ator na conversa.

O exemplo a seguir mostra como usar a classe Conversation para simular uma conversa entre dois atores.

 import { Actor , Conversation } from "@wecandobetter/phenomenal-ai" ;
import { generateText } from "./text-generation" ; // provide your own text generation function

// Define your actors
const actors = [
  new Actor ( "John" ) ,
  new Actor ( "Emma" ) ,
] ;

// Initialize a conversation
const conversation = new Conversation ( "Morning Talk" , { actors } ) ;

// Add a context entry
conversation . context . set ( "topic" , "Current topic of conversation" , "AI Ethics" ) ;

// Make a query:

const response = await conversation . query ( {
  speaker : actors [ 0 ] , // the speaker, i.e. the actor asking the question
  answerer : actors [ 1 ] , // the answerer, i.e. the actor answering the question
  query : "What is the topic of conversation?" , // the query to be answered
  generateText , // provide your own text generation function
  store : true , // store the response in the history
} ) ;

console . log ( ` ${ response . speaker } : ${ response . text } ` ) ;

// Moderate the conversation by injecting a new message:

conversation . inject ( "Let's get back to the topic of conversation." , {
  speaker : "Moderator" , // the speaker of the message (defaults to `System`)
  ephemeral : true , // this message will not be stored in the history
} ) ;

// Make one turn:

const turn = await conversation . turn ( {
  actor : conversation . scheduler . getNextSpeaker ( ) , // get the next speaker from the scheduler
  generateText , // provide your own text generation function
} ) ;

console . log ( ` ${ turn . speaker } : ${ turn . text } ` ) ;

// or use an async generator:

const ac = new AbortController ( ) ;

const loop = conversation . loop ( {
  signal : ac . signal , // provide an AbortSignal to stop the loop
  generateText , // provide your own text generation function
  scheduler : conversation . scheduler , // provide your own scheduler
} ) ;

for await ( const turn of loop ) {
  console . log ( ` ${ turn . speaker } : ${ turn . text } ` ) ;
} 

Referência da API

As principais classes deste pacote são Conversation , ConversationHistory e Actor .

Conversa

A aula Conversation representa uma conversa contínua entre vários atores.

Propriedades

• id : Identificador exclusivo para a conversa.
• name : Nome da conversa.
• actors : Matriz de Actor participando da conversa.
• history : A história da conversa.
• context : contexto compartilhado entre todos os atores da conversa.

Métodos

Estes são os métodos disponíveis na aula Conversation .

new Conversation(name: string, { actors: Actor[], generateText?: GenerateText, scheduler?: Scheduler, messages?: Message[], windowss?: { history?: number } })

Inicializa uma nova instância da classe Conversation .

 const conversation = new Conversation ( "Morning Talk" , {
  actors : [
    new Actor ( "John" ) ,
    new Actor ( "Emma" ) ,
  ] ,
  generateText : generateText , // provide your own text generation function
  scheduler : RoundRobinScheduler , // provide your own scheduler
  messages : [ ] , // bootstrap the conversation with messages
  windows : { // configure the conversation window
    max : 1024 , // the maximum number of tokens to unmask in the history
  } ,
} ) ; 

conversation.inject(text: string, { speaker = "System" embeddings?: number[][], ephemeral?: true })

Injeta uma nova mensagem na conversa. Retorna a mensagem injetada.

 const message = conversation . inject (
  "Let's get back to the topic of conversation." ,
  {
    speaker : "Moderator" ,
    ephemeral : true , // if true, the message will not be stored in the history after the next turn
  } ,
) ; 

conversation.query({ speaker: Actor, answerer: Actor, query: string, generateText?: GenerateText, store = false })

Retorna uma promessa que resolve a uma resposta de turno.

 const response = await conversation . query ( {
  speaker : actors [ 0 ] , // the speaker, i.e. the actor asking the question
  answerer : actors [ 1 ] , // the answerer, i.e. the actor answering the question
  query : "What is the topic of conversation?" , // the query to be answered
  generateText , // provide your own text generation function
  store : true , // store the response in the history
} ) ;

console . log ( ` ${ response . speaker } : ${ response . text } ` ) ; 

conversation.turn({ actor: Actor, generateText?: GenerateText })

Retorna uma promessa que resolve a uma resposta de turno.

 const response = await conversation . turn ( {
  actor : conversation . scheduler . getNextSpeaker ( ) , // get the next speaker from the scheduler
  generateText , // provide your own text generation function
} ) ;

console . log ( ` ${ response . speaker } : ${ response . text } ` ) ; 

conversation.loop({ signal: AbortSignal; generateText?: GenerateText })

Um gerador assíncrono que gera o alto -falante, o texto e, opcionalmente, as incorporações de cada turno na conversa.

 const ac = new AbortController ( ) ;

// start the loop, which will yield the responses
const loop = conversation . loop ( {
  signal : ac . signal , // provide an AbortSignal to stop the loop
  generateText , // provide your own text generation function
} ) ;

for await ( const response of loop ) {
  console . log ( ` ${ response . speaker } : ${ response . text } ` ) ;
} 

conversation.toJSON()

Retorna uma representação JSON da conversa.

 const json = conversation . toJSON ( ) ;

Conversahistory

A aula ConversationHistory representa a história de uma conversa.

Propriedades

• messages : Matriz de mensagens na conversa.

Métodos

Estes são os métodos disponíveis na aula ConversationHistory .

new ConversationHistory(messages?: Message[])

Inicializa uma nova instância da aula ConversationHistory .

 const history = new ConversationHistory ( [
  { speaker : "John" , text : "Hello, Emma!" } ,
  { speaker : "Emma" , text : "Hi, John!" } ,
] ) ; 

history.push(message: PartialBy<Message, "feedback">)

Empurra uma nova mensagem para a história.

 history . push ( { actor : "John" , text : "Hello, Emma!" } ) ; 

history.getMessagesFor(actor: string)

Retorna um mapa de índices e mensagens para o ator especificado.

 const messages = history . getMessagesFor ( "John" ) ; 

history.getStats()

Retorna estatísticas sobre a história. As estatísticas são agrupadas pelo ator.

 const stats = history . getStats ( ) ;

console . log ( stats ) ;

// {
//   "Bob": {
//     count: 2, // total number of messages
//     textCount: 22, // total number of characters
//     percentage: 0.5, // percentage of messages in the conversation
//     textPercentage: 0.5, // percentage of characters in the conversation
//   },
// } 

history.cleanEphemeral()

Remove mensagens efêmeras da história.

 history . cleanEphemeral ( ) ; 

history.up(message: Message)

Adicione feedback positivo à mensagem fornecida.

 const message = history . messages [ 0 ] ; // get message from somewhere
history . up ( message ) ; 

history.down(message: Message)

Adicione feedback negativo à mensagem fornecida.

 const message = history . messages [ 0 ] ; // get message from somewhere
history . down ( message ) ; 

history.first(): Message

Retorna a primeira mensagem na história.

history.last(): Message

Retorna a última mensagem na história.

history.toJSON()

Retorna uma representação JSON da história.

history.clear()

Limpa a história.

Ator

A classe Actor representa uma entidade que está participando de uma conversa.

Propriedades

• id : Identificador exclusivo para o ator.
• name : Nome do ator.
• template : modelo para os prompts do ator.
• context : contexto compartilhado entre todos os atores da conversa.
• persona : Persona do ator.
• knowledge : Conhecimento do ator.
• memory : Memória do ator.

Métodos

Estes são os métodos disponíveis na classe Actor .

new Actor(name: string, { template?: string, persona?: Persona, knowledge?: Knowledge, memory?: Memory })

Inicializa uma nova instância da classe Actor . Se nenhum modelo for fornecido, o modelo padrão será usado.

 const actor = new Actor ( "John" , {
  template : "Hello, my name is {{name}}." ,
) ; 

actor.render(conversation: Conversation)

Torna o modelo do ator em um prompt. O prompt é uma mensagem que pode ser usada pelo modelo de idioma grande escolhido para gerar uma resposta.

 const prompt = actor . render ( conversation ) ; 

actor.toJSON()

Retorna uma representação JSON do ator.

❤️ Contribuindo

Solicitações de tração são bem -vindas. Para grandes mudanças, abra um problema primeiro para discutir o que você gostaria de mudar. Sinta -se à vontade para verificar a página de problemas.

Licença

Este projeto está licenciado sob a licença do MIT. Sinta -se à vontade para usá -lo para seus próprios projetos.

Notas

Codificação feliz! ?

Se você encontrar algum problema ou tiver sugestões de melhorias, sinta -se à vontade para abrir um problema ou uma solicitação de tração.

Dê a um ️ se você gosta deste projeto!

Codificado com ❤️ por nós podemos fazer melhor.