lintel

KO | EN

gitlite — search

#javascript #react #llm #android #machine-learning #deep-learning #docker #nodejs #awesome #cli #awesome-list #security #mcp #openai

(★ 10)

AI-human engineering platform where AI agents and humans collaborate as teammates to plan, code, review, and ship in isolated sandboxes. An append-only event store gives a full audit trail and DORA-grade metrics derived from the stream, with built-in financial-compliance templates. FastAPI + LangGraph.

lintel 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# 🏗️ Lintel

**The AI-human engineering platform where agents and humans collaborate as teammates.**

Lintel doesn't just measure software delivery — it *executes* it. Teams interact through Slack or the web UI while specialised AI agents plan, code, review, and ship work in isolated sandboxes. Every action is recorded in an append-only event store, giving you a complete audit trail and DORA-grade metrics — all derived from the event stream, not bolted on.

> Traditional engineering intelligence platforms are mirrors — they show you what happened.
> Lintel is a flywheel — it measures, acts, and improves automatically.

<img src="docs/images/pipeline-dag.png" alt="Pipeline DAG with real-time stage tracking" width="100%">
 Pipeline DAG — visual workflow execution with real-time stage progress

<img src="docs/images/skills.png" alt="Agent skills registry" width="48%">
 <img src="docs/images/ai-providers.png" alt="Multi-provider AI configuration" width="48%">
 Left: Composable agent skills — Right: Multi-provider AI routing (Anthropic, OpenAI, Ollama, Bedrock, Azure, Google)

<img src="docs/images/regulation-templates.png" alt="Compliance regulation templates" width="80%">
 Built-in compliance regulation templates (FCA, PSD2, SM&CR, MiFID II, DORA, AML)

---

## How it works

```
  +---------+     +---------+     +--------+     +--------+     +---------+     +-------+
  | DESIRE  | --> | DEVELOP | --> | REVIEW | --> | DEPLOY | --> | OBSERVE | --> | LEARN |
  +---------+     +---------+     +--------+     +--------+     +---------+     +-------+
       ^                                                                           |
       +----------------------- learnings inform next desire ----------------------+
```

You describe what you want in a Slack thread or chat. Lintel classifies the request, builds a work plan, writes the code, runs tests, requests reviews, and waits for your approval before merging. Each phase transition is an event. Each event feeds metrics. Metrics trigger guardrails. The flywheel turns.

### Pipeline stages

```
ingest → route → setup_workspace → research → approve_research
  → plan → approve_spec → implement → test → review → approve_merge → merge
```

Every stage is observable, retryable, and produces audit events. Approval gates pause the pipeline and wait for human sign-off.

---

## Key capabilities

| | |
|---|---|
| **Multi-agent orchestration** | Specialised agents (planner, coder, reviewer, PM, designer, summarizer) collaborate within a single workflow, each routable to different LLM providers |
| **Chat-driven workflows** | Describe work in natural language — Lintel classifies intent, creates work items, and dispatches the right pipeline |
| **Sandboxed execution** | Code runs in isolated Docker containers with `--cap-drop ALL`, seccomp profiles, read-only root filesystems, and no network after clone |
| **PII protection** | Messages are scanned with Presidio and anonymised before reaching any model |
| **Event-sourced audit trail** | Every decision, model call, approval, and state change is an immutable event with full correlation tracking |
| **Human-in-the-loop** | Agents propose; humans approve merges, deployments, and sensitive actions via configurable approval gates |
| **Model-agnostic routing** | Route any agent role to any provider (OpenAI, Anthropic, Bedrock, Ollama, Azure) with priority-based model assignment policies |
| **MCP integration** | All 170+ API endpoints are automatically exposed as MCP tools, plus a client for connecting to external MCP servers |
| **Web UI** | Full-featured dashboard with 27 feature modules — pipelines, chat, sandboxes, agents, models, audit logs, and more |

---

## Architecture

```
                          ┌─────────────────┐
                          │   Slack / Chat   │
                          └────────┬────────┘
                                   │
                          ┌────────▼────────┐
                          │  PII Pipeline   │
                          └────────┬────────┘
                                   │
              ┌────────────────────▼────────────────────┐
              │           Event Store (Postgres)         │
              │  append-only · correlation · causation   │
              └────────────────────┬────────────────────┘
                                   │
              ┌────────────────────▼────────────────────┐
              │         LangGraph Workflow Engine        │
              │                                          │
              │  ┌──────────┐ ┌────────┐ ┌──────────┐  │
              │  │ Planner  │ │ Coder  │ │ Reviewer │  │
              │  └────┬─────┘ └───┬────┘ └────┬─────┘  │
              │       │           │            │         │
              │       ▼           ▼            ▼         │
              │  ┌─────────────────────────────────┐    │
              │  │    Sandboxed Execution (Docker)  │    │
              │  └─────────────────────────────────┘    │
              └────────────────────┬────────────────────┘
                                   │
              ┌────────────────────▼────────────────────┐
              │      Projections · Metrics · Audit       │
              └─────────────────────────────────────────┘
```

The system follows **event sourcing with CQRS**. Commands express intent and may fail. Events are past-tense facts that are never modified. Domain code depends on Protocol interfaces; infrastructure provides concrete implementations.

<details>
<summary>Domain model (click to expand)</summary>

```mermaid
erDiagram
    Project ||--o{ Repository : "has many"
    Project ||--o{ Credential : "has many"
    Project ||--o{ PipelineRun : "runs"
    Project ||--o{ WorkItem : "tracks"
    Project ||--o{ Trigger : "started by"
    Project ||--o{ NotificationRule : "notifies via"
    Project ||--o{ Policy : "governed by"

WorkflowDefinition ||--o{ WorkflowStepConfig : "defines steps"
    WorkflowStepConfig }o--|| AgentDefinition : "uses agent"
    WorkflowStepConfig }o--|| Model : "uses model"
    WorkflowStepConfig }o--|| AIProvider : "via provider"

PipelineRun }o--|| WorkflowDefinition : "instance of"
    PipelineRun }o--|| WorkItem : "executes"
    PipelineRun }o--|| Environment : "runs in"
    PipelineRun ||--o{ Stage : "has stages"

Stage ||--o{ AgentSession : "runs agents"
    Stage ||--o{ SandboxJob : "executes in"
    Stage ||--o{ ApprovalRequest : "may require"

SandboxJob }o--|| Repository : "operates on"
    Environment ||--o{ Variable : "has variables"

ChatSession }o--|| Project : "belongs to"
    ChatSession }o--o{ MCPServer : "has access to"
    ChatSession ||--o{ PipelineRun : "can trigger"

Model }o--|| AIProvider : "provided by"
    AgentDefinition ||--o{ SkillDefinition : "uses skills"
```

</details>

### Workspace packages

Lintel is a **uv workspace monorepo** — each package has its own `pyproject.toml`, source, and colocated tests:

```
packages/
  contracts/        lintel-contracts       — types, commands, events, Protocol interfaces (no deps)
  domain/           lintel-domain          — business logic, skills, scheduling
  agents/           lintel-agents          — AI agent runtime
  infrastructure/   lintel-infrastructure  — postgres, slack, presidio, sandbox, vault, observability
  workflows/        lintel-workflows       — LangGraph workflow graphs and node implementations
  app/              lintel                 — FastAPI API, middleware, MCP surface, composition root
```

Dependency flow: `contracts` → `domain` / `agents` → `infrastructure` / `workflows` → `app`

Domain code depends only on `contracts/` abstractions — never on infrastructure.

---

## Quick start

### Prerequisites

- Python 3.12+
- [uv](https://docs.astral.sh/uv/) package manager
- Docker (for sandboxes and local Postgres)

### Install and run

```bash
git clone https://github.com/bamdadd/lintel.git
cd lintel

# Install dependencies
make install

# Start dev server (in-memory stores, no external deps)
make serve

# Or with Postgres
make serve-db

# Open the UI
open http://localhost:8000
```

### Development workflow

**Working on a feature** — run tests for the package you're changing:

```bash
make test-contracts          # if touching contracts
make test-domain             # if touching domain
make test-agents             # if touching agents
make test-infrastructure     # if touching infrastructure
make test-workflows          # if touching workflows
make test-app                # if touching API/routes

# Or auto-detect affected packages (+ their dependents):
make test-affected BASE_REF=main

# Or use testmon for incremental testing (tracks file-to-test deps):
uv run pytest --testmon packages/domain/tests/

# Run a single test:
uv run pytest packages/contracts/tests/test_types.py -v
```

**Before pushing:**

```bash
make lint                    # ruff check + format
make typecheck               # mypy strict mode
```

**Before merging:**

```bash
make all                     # lint + typecheck + all tests + integration + UI build
```

### CI pipeline

| Trigger | Unit Tests | Integration | Lint + Typecheck |
|---------|-----------|-------------|------------------|
| **PR**  | Affected packages only | Skipped | Full |
| **Main push** | All packages | Postgres + migrations | Full |

### Docker Compose (full stack)

```bash
cp .env.example .env  # fill in your API keys
cd ops && docker compose up -d

curl http://localhost:8000/healthz
```

---

## All make targets

```
make install              Install all deps (uv sync --all-extras --all-packages)
make serve                Dev server on :8000 (in-memory)
make serve-db             Dev server on :8000 (PostgreSQL)
make test                 Run all tests
make test-affected        Run tests for changed packages only
make test-contracts       Run contracts tests
make test-domain          Run domain tests
make test-agents          Run agents tests
make test-infrastructure  Run infrastructure tests
make test-workflows       Run workflows tests
make test-app             Run app tests
make test-unit            All unit tests (parallelised)
make test-postgres        Tests against postgres backend
make test-integration     Integration tests (testcontainers)
make test-e2e             End-to-end tests
make lint                 Ruff check + format check
make typecheck            mypy strict mode
make format               Auto-fix formatting and lint
make migrate              Run event store migrations
make all                  lint + typecheck + all tests + integration + UI build
make dev                  Launch tmux dev environment (3 windows)
```

---

## Tech stack

| Layer | Technology |
|---|---|
| API | FastAPI, Pydantic v2, uvicorn |
| Workflows | LangGraph, LangChain |
| LLM routing | litellm (OpenAI, Anthropic, Bedrock, Ollama, Azure) |
| Database | PostgreSQL, asyncpg, SQLAlchemy async |
| Messaging | NATS |
| PII | Presidio (analyzer + anonymizer) |
| Sandbox | Docker (isolated containers) |
| Secrets | cryptography (Fernet) |
| Observability | OpenTelemetry (SDK + OTLP exporter) |
| Slack | slack-bolt, slack-sdk |
| MCP | fastapi-mcp (auto-expose), custom tool client |
| UI | React, Vite, Mantine, TanStack Query |
| Testing | pytest, pytest-asyncio, testcontainers |
| Code quality | ruff, mypy (strict mode) |

---

## Documentation

- [Platform Vision](docs/vision.md) — mission, principles, and differentiation
- [Architecture](docs/architecture.md) — detailed system design
- [Events](docs/events.md) — event types and the event store
- [Local Development](docs/local-dev.md) — dev environment setup
- [Requirements](docs/requirements/) — delivery loop, entities, guardrails, metrics, integrations

---

## License

[MIT](LICENSE)

lintel

lintel 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

lintel

lintel 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README