Buduj agentów w Go z pamięcią grafową i multi-wektorową

Czyste adaptery LLM, natywne narzędzia UTCP, pamięć RAG i orkiestracja multi-agentowa. Skup się na logice domenowej, a my ogarniemy „plumbing”.

QuickStart FAQ pkg.go.dev ↗

Apache-2.0 • Go 1.22+ • UTCP-ready

demo CLI

lattice> /tool echo "hello"
lattice> /calc 2*(3+4)
lattice> summarize recent notes in team:core

Pamięć grafowa

Sąsiedztwo, ważność, zanikanie — kontekst trafia w sedno.

Multi-wektor (macierz)

Wiele wektorów na rekord + fuzja RRF/weighted = lepszy recall.

Narzędzia UTCP

Jedno API, wielu dostawców i trybów uruchomienia.

Czyste adaptery LLM

Gemini, Anthropic, OpenAI, Ollama — jeden interfejs.

Wymienne magazyny

In-memory na start; produkcja: PostgreSQL+pgvector lub Qdrant.

Swarm & spaces

Specjaliści współdzielący przestrzenie zespołów i sesji.

QuickStart

Szybki start: klon, deps, klucz API, demo.

git clone https://github.com/Protocol-Lattice/go-agent.git
cd lattice-agent
go mod download

# opcjonalna trwałość
echo "CREATE EXTENSION IF NOT EXISTS vector;" | psql postgres

# env
echo 'export GEMINI_API_KEY=YOUR_KEY' >> ~/.bashrc
source ~/.bashrc

# demo
go run ./cmd/quickstart

Agent

Minimalny przykład uruchomienia agenta i wygenerowania odpowiedzi.

package main

import (
  "context"
  "log"

  "github.com/Protocol-Lattice/go-agent/src/adk"
  adkmodules "github.com/Protocol-Lattice/go-agent/src/adk/modules"
  "github.com/Protocol-Lattice/go-agent/src/models"
  "github.com/Protocol-Lattice/go-agent/src/tools"
)

func main() {
  ctx := context.Background()

  kit, err := adk.New(ctx,
    adk.WithModules(
      adkmodules.NewModelModule("coordinator", func(_ context.Context) (models.Agent, error) {
        return models.NewGeminiLLM(ctx, "gemini-2.5-pro", "Swarm orchestration:")
      }),
      adkmodules.InMemoryMemoryModule(64),
      adkmodules.NewToolModule("default-tools",
        adkmodules.StaticToolProvider([]tools.Tool{
          &tools.EchoTool{},
          &tools.CalculatorTool{},
        }, nil)),
    ),
  )
  if err != nil { log.Fatal(err) }

  a, err := kit.BuildAgent(ctx)
  if err != nil { log.Fatal(err) }

  resp, err := a.Generate(ctx, "session-1", "Co to jest pgvector? Odpowiedz w 2 linijkach.")
  if err != nil { log.Fatal(err) }
  log.Println(resp)
}

Dlaczego Lattice-Agent?

AI w produkcji potrzebuje szybkości, niezawodności i prostoty. Lattice-Agent pozwala zespołom budować agentów w Go — z pamięcią grafową, multi-wektorową i współdzieloną przestrzenią swarm. Bez zbędnego bloatu.

Wydajność

Go zapewnia natywną współbieżność i niskie zużycie zasobów — idealne dla agentów w realnych systemach.

Skalowalność

Wbudowana obsługa swarm pozwala agentom współpracować i dzielić pamięć w czasie rzeczywistym.

Prostota

Czyste API, minimalne zależności i jeden interfejs dla wszystkich dostawców LLM i narzędzi.

FAQ

Najczęstsze pytania o Lattice-Agent.

Jak działa pamięć multi-wektorowa? ▾

Każdy rekord przechowuje macierz wektorów (np. tytuł, treść, encje). Wyniki łączone są przez fuzję (RRF/weighted), a sąsiedztwo grafu rozszerza kontekst.

Jakie magazyny są wspierane? ▾

Dev: in-memory. Prod: PostgreSQL+pgvector lub Qdrant. Adaptery w pkg/memory.

Czy muszę używać Gemini? ▾

Nie. Interfejs LLM jest plug-and-play (Anthropic, OpenAI, Ollama, własne modele).

Jak kontrybuować? ▾

Małe PR-y, testy i dokumentacja. Standard library first, czysty kod, minimalne zależności.