Ollama é principalmente um wrapper em torno de llama.cpp, projetado para tarefas de inferência local. Normalmente não é sua primeira escolha se você procura desempenho ou recursos de ponta, mas tem sua utilidade, especialmente em ambientes onde dependências externas são uma preocupação.

Desenvolvimento local de IA

Ao usar o Ollama para desenvolvimento local de IA, a configuração é simples, mas eficaz. Os desenvolvedores normalmente aproveitam o Ollama para executar tarefas de inferência diretamente em suas máquinas locais. Aqui está uma representação visual de uma configuração típica de desenvolvimento local usando Ollama:

Essa configuração permite que os desenvolvedores testem e iterem rapidamente, sem as complexidades das comunicações de servidores remotos. É ideal para fases iniciais de prototipagem e desenvolvimento, onde o retorno rápido é fundamental.

Do local à nuvem

A transição de uma configuração local para um ambiente de nuvem escalável envolve evoluir de uma configuração simples 1:1 (uma solicitação de usuário para um host de inferência) para uma configuração mais complexa de muitos para muitos (múltiplas solicitações de usuário para vários hosts de inferência) . Essa mudança é necessária para manter a eficiência e a capacidade de resposta à medida que a demanda aumenta.

Veja como fica esse dimensionamento ao passar do desenvolvimento local para a produção:

Adotar uma abordagem direta durante essa transição pode aumentar significativamente a complexidade dos aplicativos, especialmente porque as sessões precisam manter a consistência em vários estados. Podem surgir atrasos e ineficiências se as solicitações não forem roteadas de maneira ideal para o melhor host de inferência disponível.

Além disso, a natureza complexa dos aplicativos distribuídos torna difícil testá-los localmente, o que pode retardar o processo de desenvolvimento e aumentar o risco de falhas em ambientes de produção.

Sem servidor

A computação sem servidor abstrai o gerenciamento do servidor e os detalhes da infraestrutura, permitindo que os desenvolvedores se concentrem apenas no código e na lógica de negócios. Ao dissociar o tratamento de solicitações e a manutenção de consistência do aplicativo, a arquitetura sem servidor simplifica o escalonamento.

Essa abordagem permite que o aplicativo permaneça concentrado na entrega de valor, resolvendo muitos desafios comuns de escalabilidade sem sobrecarregar os desenvolvedores com complexidades de infraestrutura.

WebAssembly

WebAssembly (Wasm) aborda o desafio do gerenciamento de dependências, permitindo a compilação de aplicativos em módulos independentes. Isso torna os aplicativos mais fáceis de orquestrar e testar localmente e na nuvem, garantindo consistência em diferentes ambientes.

Tau

Tau é uma estrutura para construir plataformas de computação em nuvem de baixa manutenção e altamente escaláveis. É excelente em simplicidade e extensibilidade. Tau simplifica a implantação e oferece suporte à execução de uma nuvem local para desenvolvimento, permitindo testes ponta a ponta (E2E) da infraestrutura da nuvem e dos aplicativos executados nela.

Esta abordagem, referida por Taubyte como "Codificação local igual à produção global", garante que o que funciona localmente funcionará globalmente, facilitando significativamente os processos de desenvolvimento e implantação.

Integrando Ollama ao Tau com o Orbit Plugin System

O sistema de plug-ins do Tau, conhecido como Orbit, simplifica significativamente a transformação de serviços em componentes gerenciáveis, agrupando-os em módulos host WebAssembly. Essa abordagem permite que Tau assuma as funções de orquestração, agilizando o processo de implantação e gerenciamento.

Exportando funções no Ollama

Para tornar as funções do Ollama acessíveis dentro do ecossistema do Tau, utilizamos o sistema Orbit para exportar os recursos do Ollama como endpoints que podem ser chamados. Veja como você pode exportar um endpoint em Go:

func (s *ollama) W_pull(ctx context.Context, module satellite.Module, modelNamePtr uint32, modelNameSize uint32, pullIdptr uint32) Error {
    model, err := module.ReadString(modelNamePtr, modelNameSize)
    if err != nil {
        return ErrorReadMemory
    }

    id, updateFunc := s.getPullId(model)

    if updateFunc != nil {
        go func() {
            err = server.PullModel(s.ctx, model, &server.RegistryOptions{}, updateFunc)
            s.pullLock.Lock()
            defer s.pullLock.Unlock()
            s.pulls[id].err = err
        }()
    }

    module.WriteUint64(pullIdptr, id)

    return ErrorNone
}

Para obter um exemplo simples de exportação de funções, você pode consultar o exemplo hello_world.

Uma vez definidas, essas funções, agora chamadas via satélite.Export, permitem a integração perfeita do Ollama no ambiente do Tau:

func main() {
    server := new(context.TODO(), "/tmp/ollama-wasm")
    server.init()
    satellite.Export("ollama", server)
}

Escrevendo testes para o plugin Ollama

Testar o plugin é simplificado e direto. Veja como você pode escrever um teste de função sem servidor em Go:

//export pull
func pull() {
    var id uint64
    err := Pull("gemma:2b-instruct", &id)
    if err != 0 {
        panic("failed to call pull")
    }
}

Usando o conjunto de testes do Tau e as ferramentas de construção Go, você pode construir seu plugin, implantá-lo em um ambiente de teste e executar as funções sem servidor para verificar a funcionalidade:

func TestPull(t *testing.T) {
    ctx := context.Background()

    // Create a testing suite to test the plugin
    ts, err := suite.New(ctx)
    assert.NilError(t, err)

    // Use a Go builder to build plugins and wasm
    gob := builder.New()

    // Build the plugin from the directory
    wd, _ := os.Getwd()
    pluginPath, err := gob.Plugin(path.Join(wd, "."), "ollama")
    assert.NilError(t, err)

    // Attach plugin to the testing suite
    err = ts.AttachPluginFromPath(pluginPath)
    assert.NilError(t, err)

    // Build a wasm file from serverless function
    wasmPath, err := gob.Wasm(ctx, path.Join(wd, "fixtures", "pull.go"), path.Join(wd, "fixtures", "common.go"))
    assert.NilError(t, err)

    // Load the wasm module and call the function
    module, err := ts.WasmModule(wasmPath)
    assert.NilError(t, err)

    // Call the "pull" function from our wasm module
    _, err = module.Call(ctx, "pull")
    assert.NilError(t, err)
}

Código

Você pode encontrar o código completo aqui https://github.com/ollama-cloud/ollama-as-wasm-plugin/tree/main/tau

Qual é o próximo?

Agora você pode criar aplicativos LLM com facilidade. Aqui estão as etapas para começar:

• Comece localmente usando o dream: configure seu ambiente local para desenvolver e testar seu aplicativo.
• Crie um projeto: Comece um novo projeto com Tau para aproveitar todo o seu potencial.
• Crie sua nuvem de produção: implante seu projeto em um ambiente de nuvem de produção.
• Solte o binário do plugin na pasta /tb/plugins.
• Importe seu projeto para produção
• Mostrar!