**[2026-10-01]** LightAgent v0.11.0 lançado: adiciona DAGs dinâmicos multiagente persistentes e opcionais, artefatos imutáveis publicados somente após verificação, recuperação com leases e fencing e um `SecurityContext` unificado com permissões que só podem ser reduzidas e controles de aprovação.
- **[2026-08-15]** LightAgent v0.10.0 lançado: introduz o runtime baseado em eventos com Sessions persistentes, execução assíncrona, Capability Registry e Policy, Inbox, Goals, Budgets, Jobs, subagentes, compactação de contexto e busca SQLite FTS5.
- **[2026-08-15]** LightAgent v0.9.7 lançado: adiciona um contrato Connector leve e sem dependências com validação offline e exemplos, amplia as verificações de segurança do executor Python, introduz uma matriz de segurança opcional para Mem0 Graph e prepara a estabilização da v1.0 com um inventário de compatibilidade da API pública.
- **[2026-07-30]** LightAgent v0.9.6 lançado: adiciona resumos e exportadores de trace para produção, avaliação determinística, aprovação humana persistente para ferramentas, handoffs e LightFlow, além de admissão de escrita fail-closed e controles de auditoria para memória gráfica compartilhada.
- **[2026-06-24]** LightAgent v0.9.0: adiciona workflows LightFlow com checkpoints, resume/rerun, nós de aprovação, estados de etapa mais claros, metadados de trace, modelos Guardrails, controles MemoryPolicy e o protótipo SharedMemoryPool.
- **[2026-06-14]** LightAgent v0.8.1: adiciona convenções MemoryScope e filtros MemoryPolicy por origem, escopo e confiança.
- **[2026-06-02]** LightAgent v0.8.0: introduz LightFlow para workflows determinísticos de várias etapas.
Notas antigas estão em [GitHub Releases](https://github.com/wanxingai/LightAgent/releases).
---
## ✨ Funcionalidades
- **Leve e eficiente**: Framework Python modular e de código aberto, sem LangChain nem LlamaIndex, com dependências específicas para modelos, MCP, memória e rastreamento.
- **Runtime baseado em eventos**: Sessões persistentes opcionais, replay, checkpoints, chamadas assíncronas, Capability e Policy, Inbox, Goals, Budgets, Jobs, subagentes, compactação do contexto e busca SQLite FTS5.
- **DAGs dinâmicos verificados**: LightDAG persiste alterações do grafo, executa Workers independentes em paralelo e publica artefatos imutáveis somente após verificação definida pela aplicação.
- **Suporte a memória** 🧠: Suporte a customização de memória de longo prazo para cada usuário, com o módulo de memória `mem0`, gerenciando automaticamente memórias personalizadas do usuário durante o diálogo, tornando o agente mais inteligente.
- **Aprendizado autônomo** 📚️: Cada agente tem a capacidade de aprender de forma autônoma, enquanto administradores com permissões podem gerenciar cada agente.
- **Integração de ferramentas** 🛠️: Suporte a ferramentas personalizadas (`Tools`), geração automatizada de ferramentas, flexibilidade para atender a diversas necessidades.
- **Objetivos complexos** 🌳: Módulo de árvore de raciocínio (ToT) incorporado, suportando decomposição de tarefas complexas e raciocínio em múltiplos passos, aprimorando a capacidade de lidar com tarefas.
- **Colaboração multiagente** 🤖: Colaboração multiagente mais simples de implementar do que o Swarm, com LightSwarm incorporado para avaliação de intenções e transferência de tarefas, capaz de processar entradas de usuário de forma mais inteligente e transferir tarefas para outros agentes conforme necessário.
- **Execução independente** 🤖: Conclusão autônoma da chamada de ferramentas sem intervenção humana.
- **Suporte a múltiplos modelos** 🔄: Compatível com OpenAI, ChatGLM, Baichuan, DeepSeek e séries de modelos Qwen.
- **API em tempo real** 🌊: Suporte à saída de serviços de API em formato de fluxo OpenAI, integrado perfeitamente aos principais frameworks de chat, melhorando a experiência do usuário.
- **Gerador de ferramentas** 🚀: Basta fornecer sua documentação de API ao [gerador de ferramentas], que ele criará automaticamente suas ferramentas personalizadas, permitindo a construção rápida de centenas de ferramentas personalizadas em apenas 1 hora, aumentando a eficiência e liberando seu potencial criativo.
- **Auto-aprendizado de agentes** 🧠️: Cada agente terá sua própria capacidade de memória de cenário, permitindo o aprendizado autônomo a partir das interações do usuário.
- **Mecanismo adaptativo de ferramentas** 🛠️: Suporte à adição de ferramentas em quantidade ilimitada, permitindo que o modelo grande selecione um conjunto de ferramentas candidatas entre milhares de opções, filtrando as irrelevantes antes de enviar o contexto para o modelo grande, reduzindo significativamente o consumo de tokens.
- **Orquestração de workflows** 🔁: LightFlow encadeia agentes em workflows determinísticos com dependências explícitas, passagem de saídas, retentativas, checkpoints, resume/rerun, aprovações, agentes fallback e execução rastreável.
- **Protótipo de memória compartilhada** 🧠: SharedMemoryPool fornece memória compartilhada em memória com metadados de procedência, recuperação por escopo e resultados compatíveis com MemoryPolicy.
- **Modelos Guardrails** 🛡️: Políticas reutilizáveis de entrada, ferramentas e saída bloqueiam dados privados, confirmam ferramentas sensíveis, validam parâmetros de alto risco e redigem saídas.
- **Runtime Hooks** 🧩: Middleware ordenado `hooks=[...]` para observar, substituir ou bloquear fases de execução, modelo, ferramenta, memória e etapas LightFlow.
- **Avaliação e revisão humana** 📊: `LightEvaluator` executa regressões determinísticas; `HumanApprovalHook`, review stores persistentes e checkpoints LightFlow suportam aprovação, rejeição, edição de argumentos e feedback.
## 🧭 Arquitetura em resumo
| Camada | API principal | Use quando precisar |
| --- | --- | --- |
| Runtime de agente único | `LightAgent` | Um agente com modelo, ferramentas, memória, streaming, trace e guardrails. |
| Estado persistente do runtime | `Session`, `AgentRuntime` | Replay, checkpoints, Inbox, Goals, Budgets, Jobs e recuperação do contexto. |
| Camada de capacidades | `CapabilityRegistry`, `PolicyEngine` | Provedores com escopo limitado, políticas, ciclo de vida e auditoria. |
| Contexto de segurança unificado | `SecurityContext`, `CapabilityGate`, `ApprovalToken` | Identidade, permissões que só podem ser reduzidas, autorização e aprovações vinculadas a uma operação. |
| Roteamento multiagente | `LightSwarm` | Delegação por papéis entre agentes especializados. |
| Workflow determinístico | `LightFlow` | DAG, retentativas, checkpoints, aprovações, resume e rerun. |
| Workflow dinâmico verificado | `LightDAG` | Decomposição dinâmica, verificadores, artefatos, Workers paralelos e recuperação. |
| Ferramentas e integrações | `tools`, `ToolRegistry`, MCP | Ferramentas Python, geradas, carregamento em runtime ou servidores MCP. |
| Limite de memória | `MemoryPolicy`, `MemoryScope` | Isolamento de tenants, procedência, confiança, expiração e admissão de escrita. |
| Memória compartilhada | `SharedMemoryPool` | Experimentos de memória compartilhada entre agentes. |
| Segurança | `input_guardrails`, `tool_guardrails`, `output_guardrails` | Privacidade, confirmação de ferramentas, parâmetros de risco e redação de saída. |
| Runtime hooks | `hooks`, `HookContext`, `HookDecision` | Política, auditoria, redação, roteamento e mutação de payloads nas fronteiras do ciclo de vida. |
| Observabilidade | `trace=True`, `agent.export_trace()` | Eventos estruturados de execução, modelo, ferramenta, erro e workflow. |
## Padrões principais de uso
LightAgent mantém a chamada padrão simples e permite adicionar controles de produção gradualmente.
| Padrão | Chamada mínima | Notas |
| --- | --- | --- |
| Resposta básica | `agent.run(query)` | Retorna string por padrão. |
| Streaming | `agent.run(query, stream=True)` | Retorna chunks compatíveis com OpenAI. |
| Resultado estruturado | `agent.run(query, result_format="object")` | Retorna conteúdo e metadados. |
| Trace | `agent.run(query, trace=True)` | Registra eventos sem mudar a string padrão. |
| Memória de usuário | `agent.run(query, user_id="alice")` | Usa backend de memória e MemoryPolicy configurados. |
| Ferramentas | `LightAgent(..., tools=[fn])` | Funções devem expor `tool_info`. |
| Guardrails | `LightAgent(..., input_guardrails=[...])` | Adiciona políticas de entrada, ferramenta e saída. |
| Runtime hooks | `LightAgent(..., hooks=[fn])` | Observa, substitui ou bloqueia payloads do ciclo de vida. |
| Workflow | `LightFlow().step(...).run(query)` | Para execução determinística multi-etapa. |
| Workflow dinâmico | `LightDAG(...).create_run(...)` | Propor tarefas e verificar resultados antes da publicação. |
| Sessão persistente | `agent.run(query, session_id="project-42")` | Exige um SessionStore persistente configurado para replay e continuação. |
| Assíncrono | `await agent.arun(query)` | Entrada não bloqueante para aplicações asyncio. |
## v0.11.0: Workflows dinâmicos verificados
Use `LightSwarm` para roteamento por papéis, `LightFlow` para etapas conhecidas e o `LightDAG` opcional quando os Workers precisarem propor novas tarefas durante a execução.
- `SqliteTaskGraphStore` persiste tarefas, tentativas, alterações do grafo, eventos e estado de recuperação. Instâncias independentes de Worker podem executar em paralelo.
- Os Workers retornam `TaskOutcome.candidate(...)`, `TaskOutcome.decompose(...)` ou `TaskOutcome.blocked(...)`. Somente um Verifier definido pela aplicação pode aprovar decomposições ou publicar artefatos imutáveis.
- Leases e fencing rejeitam tentativas antigas durante a recuperação. `SecurityContext`, `CapabilityGate` e `ApprovalToken` vinculado à operação explicitam identidade, permissões que só podem ser reduzidas e aprovações.
### Exemplo LightDAG offline
Não exige modelo, chave de API nem rede. Usa um banco SQLite e um diretório de artefatos temporários, removidos ao terminar.
```python
from pathlib import Path
from tempfile import TemporaryDirectory
from LightAgent import (
CallableVerifier, LightDAG, LocalArtifactStore, PermissionSet,
SecurityContext, SqliteTaskGraphStore, TaskOutcome, TaskSpec,
)
with TemporaryDirectory() as directory:
root = Path(directory)
store = SqliteTaskGraphStore(root / "dag.sqlite3")
try:
dag = LightDAG(
store=store,
artifact_store=LocalArtifactStore(root / "artifacts"),
verifiers={"exact": CallableVerifier(
"exact", lambda request: request.candidate_content == b"42",
)},
)
dag.register_worker("local", lambda context: TaskOutcome.candidate("42"))
dag.create_run([TaskSpec(
task_id="answer", goal="42",
acceptance_contract={"equals": "42"},
worker_key="local", verifier_key="exact",
)], run_id="readme-demo", context=SecurityContext(
user_id="alice", tenant_id="demo", project_id="readme",
permissions=PermissionSet(allowed=frozenset({"dag.task.execute"})),
))
result = dag.run("readme-demo")
assert result.success
print(result.status.value)
finally:
store.close()
```
Para persistência real, mantenha caminhos explícitos para banco e artefatos em vez de diretórios temporários. O [exemplo completo de decomposição e reparo](example/14.dynamic_dag.py) e o [guia LightDAG](docs/lightdag.md) cobrem dependências, integração, novas tentativas e recuperação.
O [guia do runtime](docs/runtime_v010.md) explica sessões persistentes, chamadas assíncronas, Capability Providers, Policy, Inbox, Goals, Budgets e Jobs.
### Compatibilidade e limites de segurança
- `agent.run(query)`, `stream=True` e `user_id` continuam disponíveis. LightDAG é opcional e não substitui LightFlow.
- v0.11.0 limita-se a um host, SQLite local e um escalonador ativo por execução. A execução é pelo menos uma vez; efeitos externos exigem idempotência. Workers distribuídos, interface web e sandbox de código integrada não estão incluídos.
- Os antigos `execute_python_code`, `execute_python_file` e `execute_python_code_stream` são bloqueados na execução de ferramentas pelo modelo, mesmo com `enable_unsafe_python=True` ou um `SandboxProvider` registrado. Use `safe_expression` ou uma ferramenta realmente isolada; chamadas diretas a esses utilitários não são uma sandbox de segurança.
- As políticas de procedência, admissão e promoção de memória continuam necessárias. Testes do framework não certificam um backend real de memória gráfica compartilhada; consulte [segurança de memória](docs/memory_security.md).
### Versão publicada e main atual
[v0.11.0](https://github.com/wanxingai/LightAgent/releases/tag/v0.11.0) foi publicada em 2026-10-01. Correções posteriores de JSON de seleção de ferramentas, MCP SDK 1.x/2.x e o exemplo opcional deed.page foram integrados após esse tag e podem não estar no pacote publicado. O comando a seguir instala o `main` atual, não o tag original:
```bash
pip install --upgrade "git+https://github.com/wanxingai/LightAgent.git@main"
```
Consulte [Tools Guide](docs/tools.md), o [adaptador Memcode](docs/memcode_memory_adapter.md) opcional, o [exemplo deed.page](docs/deed_page_mcp.md) e o [inventário de compatibilidade pública](docs/public_api_compatibility.md). Esses serviços externos não são obrigatórios para o runtime principal.
## 📋 Documentação
- Para instalação, modelos, ferramentas, memória, MCP, Skills, streaming e LightSwarm, consulte [FAQ](docs/FAQ.md).
- Para workflows determinísticos, checkpoints, resume/rerun, aprovações, agentes fallback e estados de etapa, consulte [LightFlow](docs/lightflow.md).
- Para ferramentas customizadas, ToolRegistry, ToolLoader, AsyncToolDispatcher e MCP, consulte [Tools Guide](docs/tools.md).
- Para memória compartilhada ou memória em grafo, consulte [Memory Security Guidance](docs/memory_security.md).
- Para SharedMemoryPool, consulte [SharedMemoryPool](docs/shared_memory_pool.md).
- Para admissão de escrita de memória e expiração, consulte [Memory Admission And Mutation Controls](docs/memory_admission.md).
- Para segurança de entrada, ferramentas e saída, consulte [Guardrails](docs/guardrails.md).
- Para middleware runtime que observa, substitui ou bloqueia payloads, consulte [Runtime Hooks](docs/runtime_hooks.md).
- Para OpenRouter, modelos locais e provedores compatíveis com OpenAI, consulte [Model Provider Configuration](docs/model_providers.md).
- Para traces estruturados, consulte [Trace Observability](docs/tracing.md).
- Para regressões determinísticas, consulte [Evaluation Harness](docs/evaluation.md).
- Para aprovação de ferramentas/handoffs, revisão persistente e feedback, consulte [Human Review](docs/human_review.md).
## Roteiro
Consulte o [roteiro](roadmap.md) para os marcos entregues e os planos futuros. Inbox, Jobs e subagentes já estão disponíveis no runtime opcional.
## 🌟 Por que escolher o LightAgent?
- **Open source e gratuito** 💖: Totalmente open source, dirigido pela comunidade, atualizações contínuas, contribuições são bem-vindas!
- **Fácil de usar** 🎯: Documentação detalhada, exemplos ricos, fácil integração ao seu projeto.
- **Suporte da comunidade** 👥: Comunidade de desenvolvedores ativa, pronta para ajudar e responder a suas perguntas.
- **Alto desempenho** ⚡: Design otimizado, operação eficiente, atendendo a necessidades de alto tráfego.
---
## 🛠️ Começando rapidamente
### Instale a versão mais recente do LightAgent
```bash
pip install lightagent
```
(Instalação opcional) Instale o pacote Mem0 via pip:
```bash
pip install mem0ai
```
Ou você pode usar o Mem0 em uma plataforma de hospedagem clicando [aqui](https://www.mem0.ai/).
### Exemplo de código Hello world
```python
from LightAgent import LightAgent
# Inicializa o Agente
agent = LightAgent(model="gpt-4o-mini", api_key="your_api_key", base_url= "your_base_url")
# Executa o Agente
response = agent.run("Olá, quem é você?")
print(response)
```
### Inspecionar um trace de execução (v0.7.0)
Trace é opcional e mantém compatível o comportamento padrão de `agent.run()`.
```python
from LightAgent import LightAgent
agent = LightAgent(model="gpt-4.1", api_key="your_api_key", base_url="your_base_url")
result = agent.run("Hello, who are you?", result_format="object", trace=True)
print(result.content)
print(result.trace_id)
print(result.trace)
for event in agent.export_trace():
print(event["type"], event["data"])
```
### Criar checkpoint de uma execução LightFlow (v0.9.0)
`LightFlow` pode persistir checkpoints e retomar execuções com falha sem reiniciar do primeiro passo.
```python
from LightAgent import JsonLightFlowStore, LightAgent, LightFlow
research_agent = LightAgent(model="gpt-4.1", api_key="your_api_key", base_url="your_base_url")
writer_agent = LightAgent(model="gpt-4.1", api_key="your_api_key", base_url="your_base_url")
store = JsonLightFlowStore(".lightflow_runs")
flow = (
LightFlow(store=store)
.step("research", agent=research_agent, timeout=30)
.step("write", agent=writer_agent, depends_on=["research"], max_retry=2)
)
result = flow.run("Analyze this company", run_id="report-001", trace=True)
if not result.success:
result = flow.resume("report-001")
print(result.status)
print(flow.get_run("report-001")["steps"])
```
### Usar SharedMemoryPool (v0.9.0)
`SharedMemoryPool` é um protótipo leve em memória para experimentos de memória compartilhada multiagente.
```python
from LightAgent import LightAgent, MemoryPolicy, SharedMemoryPool
shared_memory = SharedMemoryPool(agent_name="writer")
agent = LightAgent(
name="writer",
model="gpt-4.1",
api_key="your_api_key",
base_url="your_base_url",
memory=shared_memory,
memory_policy=MemoryPolicy(
namespace="tenant-a",
allow_unattributed_results=False,
allowed_sources=("user",),
allowed_scopes=("user",),
),
)
agent.run("Remember that I prefer concise reports.", user_id="alice")
print(shared_memory.list_records(user_id="tenant-a:alice"))
```
### Definindo a auto-percepção do modelo através do sistema de prompt
```python
from LightAgent import LightAgent
# Inicializa o Agente
agent = LightAgent(
role="Por favor, lembre-se de que você é o LightAgent, um assistente útil que pode ajudar os usuários com o uso de múltiplas ferramentas.", # descrição do papel do sistema
model="deepseek-chat", # modelos suportados: openai, chatglm, deepseek, qwen, etc.
api_key="your_api_key", # substitua pela chave de API de seu fornecedor de modelo grande
base_url="your_base_url", # substitua pela URL API de seu fornecedor de modelo grande
)
# Executa o Agente
response = agent.run("Quem é você?")
print(response)
```
### Exemplo de código usando ferramentas
```python
from LightAgent import LightAgent
# Define a ferramenta
def get_weather(city_name: str) -> str:
"""
Obtém o clima atual para `city_name`
"""
return f"Resultado da consulta: O clima em {city_name} está ensolarado."
# Informações de ferramenta definidas dentro da função
get_weather.tool_info = {
"tool_name": "get_weather",
"tool_description": "Obtém as informações climáticas atuais para a cidade especificada",
"tool_params": [
{"name": "city_name", "description": "Nome da cidade a ser consultada", "type": "string", "required": True},
]
}
tools = [get_weather]
# Inicializa o Agente
agent = LightAgent(model="qwen-turbo-2024-11-01", api_key="your_api_key", base_url= "your_base_url", tools=tools)
# Executa o Agente
response = agent.run("Por favor, verifique a situação do clima em Xangai.")
print(response)
```
Suporte a um número ilimitado de ferramentas personalizadas.
Exemplos de múltiplas ferramentas: tools = [search_news,get_weather,get_stock_realtime_data,get_stock_kline_data]
---
## Explicação das funcionalidades
README mantém o modelo central de uso; exemplos longos, configuração de adaptadores e práticas de produção ficam nos docs dedicados.
### 1. Módulo de memória destacável (`mem0`)
LightAgent aceita qualquer backend de memória com `store(data, user_id)` e `retrieve(query, user_id)`. Use `user_id` para isolar conversas e `MemoryPolicy` quando a memória for compartilhada.
### 2. Integração de ferramentas
Use funções Python com metadados `tool_info` para expor capacidades controladas. Para ToolRegistry, ToolLoader, AsyncToolDispatcher e MCP, consulte [Tools Guide](docs/tools.md).
### 3. Gerador de ferramentas
`agent.create_tool()` pode gerar código de ferramentas a partir de documentação de API ou descrições naturais. Revise e teste antes de produção.
### 4. Árvore de Pensamento (ToT)
Ative `tree_of_thought=True` quando a tarefa exigir planejamento explícito, reflexão e seleção de ferramentas.
### 5. Colaboração multiagente
`LightSwarm` delega trabalho entre agentes especializados. Mantenha papéis claros e controle escritas de memória.
### 6. API streaming
`agent.run(query, stream=True)` retorna chunks compatíveis com OpenAI para chat UIs e respostas longas.
### 7. Autoaprendizado do agente
Autoaprendizado deve ser combinado com `MemoryPolicy` para evitar conteúdo privado, expirado ou irrelevante.
### 8. Trace e Langfuse
LightAgent permite observar execução por trace integrado ou Langfuse.
### 9. Avaliação de agentes
`LightEvaluator` mede saída, uso de ferramentas, eventos de política, recuperação, latência e custo.
### 10. Workflows LightFlow
`LightFlow` é a camada de workflow determinística para executar etapas conhecidas.
- Estados de etapa: `pending`, `running`, `success`, `failed`, `skipped`, `waiting_approval`.
- Validação DAG: `flow.validate(strict=True)`.
- Controles de etapa: `timeout`, `max_retry`, `cancel_if`, `fallback_agent`, `requires_approval`, `approval_handler`.
- Persistência e recuperação: `JsonLightFlowStore`, `flow.resume(run_id)`, `flow.rerun_step(run_id, step_name)`, `flow.get_run(run_id)`, `flow.list_runs()`.
Consulte [LightFlow](docs/lightflow.md).
### 11. Guardrails
Guardrails são hooks leves para entrada, chamadas de ferramenta e saída.
```python
from LightAgent import (
LightAgent,
high_risk_parameter_guardrail,
output_redaction_guardrail,
privacy_input_guardrail,
sensitive_tool_confirmation_guardrail,
)
agent = LightAgent(
model="gpt-4.1",
api_key="your_api_key",
base_url="your_base_url",
input_guardrails=[privacy_input_guardrail()],
tool_guardrails=[
sensitive_tool_confirmation_guardrail(["transfer_money"], approved=False),
high_risk_parameter_guardrail({"amount": lambda value: float(value) <= 1000}),
],
output_guardrails=[output_redaction_guardrail()],
)
```
Consulte [Guardrails](docs/guardrails.md).
### 12. SharedMemoryPool
`SharedMemoryPool` é um protótipo em memória para memória compartilhada multiagente, usado com `MemoryPolicy`.
## Modelos principais de Agentes suportados
LightAgent funciona com endpoints chat completion compatíveis com OpenAI: OpenAI, OpenRouter, Zhipu ChatGLM, DeepSeek, Qwen, StepFun, Moonshot/Kimi, MiniMax, vLLM, llama.cpp, Ollama e gateways próprios.
For provider-specific parameters, base URLs, local model setup, and troubleshooting, see [Model Provider Configuration](docs/model_providers.md).
## Cenários de uso
- **Atendimento ao cliente inteligente**: Através de diálogos multironda e integração de ferramentas, proporcionando suporte ao cliente eficiente.
- **Análise de dados**: Utilizando árvores de raciocínio e colaboração multiagente, lidando com tarefas de análise de dados complexas.
- **Ferramentas automatizadas**: Usando geração automatizada de ferramentas, construindo rapidamente ferramentas personalizadas.
- **Assistência educacional**: Oferecendo experiências de aprendizagem personalizadas por meio de módulos de memória e API em tempo real.
---
## 🛠️ Guias de contribuição
Agradecemos qualquer forma de contribuição! Seja código, documentação, testes ou feedback, todos são de grande ajuda para o projeto. Se você tiver boas ideias ou encontrar Bugs, por favor, apresente um Issue ou Pull Request. Aqui estão as etapas para contribuir:
1. **Fork este projeto**: Clique no botão `Fork` no canto superior direito para copiar o projeto para seu repositório GitHub.
2. **Crie uma branch**: Crie uma branch de desenvolvimento local:
```bash
git checkout -b feature/SuaFuncionalidade
```
3. **Submeta suas alterações**: Após a conclusão do desenvolvimento, submeta suas alterações:
```bash
git commit -m 'Adicionando nova funcionalidade'
```
4. **Envie a branch**: Envie a branch para o seu repositório remoto:
```bash
git push origin feature/SuaFuncionalidade
```
5. **Submeta um Pull Request**: Apresente um Pull Request no GitHub, descrevendo o que você alterou.
Revisaremos sua contribuição assim que possível, agradecemos seu apoio!❤️
---
## 🙏 Agradecimentos
O desenvolvimento e implementação do LightAgent não seriam possíveis sem a inspiração e apoio dos seguintes projetos open source, com um agradecimento especial a estas incríveis equipes:
- **mem0**: Agradecimentos ao [mem0](https://github.com/mem0ai/mem0) pelo fornecimento do módulo de memória, que oferece suporte robusto para gerenciamento de contexto no LightAgent.
- **Swarm**: Agradecimentos ao [Swarm](https://github.com/openai/swarm) pela concepção de colaboração multiagente, que serve como base para as funcionalidades multiagente do LightAgent.
- **ChatGLM3**: Agradecimentos ao [ChatGLM3](https://github.com/THUDM/ChatGLM3) pelo suporte de modelos grandes de alto desempenho em chinês e por inspirar o design.
- **Qwen**: Agradecimentos ao [Qwen](https://github.com/QwenLM/Qwen) pelo suporte de modelos grandes de alto desempenho em chinês.
- **DeepSeek-V3**: Agradecimentos ao [DeepSeek-V3](https://github.com/deepseek-ai/DeepSeek-V3) pelo suporte de modelos grandes de alto desempenho em chinês.
- **StepFun**: Agradecimentos à [step](https://www.stepfun.com/) pelo suporte de modelos grandes de alto desempenho em chinês.
---
## 📄 Licença
LightAgent usa a [Licença Apache 2.0](LICENSE). Você pode usar, modificar e distribuir este projeto livremente, mas deve respeitar os termos da licença.
---
## 📬 Contate-nos
Para qualquer dúvida ou sugestão, não hesite em entrar em contato conosco:
- **Email**: service@wanxingai.com
- **Issues no GitHub**: [https://github.com/wanxingai/LightAgent/issues](https://github.com/wanxingai/LightAgent/issues)
Aguardamos seu feedback para tornar o LightAgent ainda mais poderoso!🚀
- **Mais ferramentas** 🛠️: Integração contínua de mais ferramentas úteis para atender a mais necessidades de cenários.
- **Mais suporte a modelos** 🔄: Expansão contínua para suportar mais modelos grandes, atendendo a mais casos de uso.
- **Mais funcionalidades** 🎯: Mais funcionalidades úteis, atualizações contínuas, fique atento para mais novidades!
- **Mais documentação** 📚: Documentação expansiva, exemplos muitos, fácil implementação nos seus projetos.
- **Mais apoio da comunidade** 👥: Comunidade de desenvolvedores ativa, disponível para ajudá-lo a qualquer momento.
- **Mais otimizações de desempenho** ⚡: Otimizações contínuas para atender a necessidades de cenários de alta concorrência.
- **Mais contribuições open source** 🌟: Contribuições de código são bem-vindas, vamos criar um LightAgent ainda melhor juntos!
---
LightAgent - Reduzindo a complexidade da inteligência, simplificando o futuro. 🌈
**LightAgent** —— Estrutura de agente leve, flexível e poderosa para ajudá-lo a construir aplicações inteligentes rapidamente!