Версия: 1.0.0
Дата: 2025-11-10
Статус: Blueprint для разработки
Цель: Создать самосовершенствующуюся платформу разработки с мульти-агентной архитектурой.
Принцип: Платформа разрабатывается по своим же правилам — минимальная система создаёт остальные компоненты.
Подход: Bootstrap development — создаём 3 базовых агента вручную, они создают остальные.
ФАЗА 0: Bootstrap Foundation (1-2 дня)
↓
ФАЗА 1: Self-Creation (2-3 дня)
↓
ФАЗА 2: Central Coordination (1-2 дня)
↓
ФАЗА 3: Full Lifecycle (3-5 дней)
↓
ФАЗА 4: Meta-Improvement (3-5 дней)
↓
ФАЗА 5: Voice Interface (5-7 дней)
ИТОГО: 15-24 дня от нуля до полной платформы
Python: 3.11+
Package Manager: pip / poetry
Version Control: Git
Claude API: anthropic-sdk (latest)
IDE: VSCode / PyCharm / Claude Code
Testing: pytest, Playwright
Documentation: Markdown
CI/CD: GitHub Actions (optional)
Database: SQLite (dev) → PostgreSQL (prod)
File Storage: Local FS → S3 (optional)
Message Queue: In-memory → Redis (optional)
Voice: Whisper API, ElevenLabs API (Phase 5)
Цель: Создать минимальные 3 агента вручную, которые смогут создать остальные.
Длительность: 1-2 дня
Усилия: ~650 строк кода (ручная разработка)
Язык: Python 3.11+
API: anthropic-sdk
Структура: Простые классы (без фреймворков)
Конфигурация: YAML файлы
Логирование: Python logging
Файловая система: pathlib
/opt/claude-workspace/
├── platform/
│ ├── agents/ # Агенты
│ │ ├── __init__.py
│ │ ├── base_agent.py # Базовый класс
│ │ ├── document_agent.py # Агент документации
│ │ ├── code_agent.py # Агент кода
│ │ └── git_agent.py # Агент Git
│ ├── api/
│ │ └── agent_api.py # API для взаимодействия агентов
│ ├── config/
│ │ ├── agents.yaml # Конфигурация агентов
│ │ └── claude.yaml # Настройки Claude API
│ └── utils/
│ ├── cascade_search.py # Cascade Search реализация
│ └── file_manager.py # Работа с файлами
1.1. Создать базовый класс агента
# platform/agents/base_agent.py
from abc import ABC, abstractmethod
from anthropic import Anthropic
import yaml
from pathlib import Path
class BaseAgent(ABC):
"""
Базовый класс для всех агентов
"""
def __init__(self, name: str, workspace_path: str):
self.name = name
self.workspace = Path(workspace_path)
self.config = self._load_config()
self.claude = Anthropic(api_key=self.config['claude_api_key'])
self.context = {}
def _load_config(self) -> dict:
"""Загрузить конфигурацию агента"""
config_path = self.workspace / 'platform' / 'config' / 'agents.yaml'
with open(config_path) as f:
return yaml.safe_load(f)
@abstractmethod
def execute(self, task: dict) -> dict:
"""Выполнить задачу (каждый агент реализует сам)"""
pass
def call_claude(self, prompt: str, system: str = None) -> str:
"""Вызов Claude API"""
messages = [{"role": "user", "content": prompt}]
kwargs = {
"model": "claude-sonnet-4-5-20250929",
"max_tokens": 4096,
"messages": messages
}
if system:
kwargs["system"] = system
response = self.claude.messages.create(**kwargs)
return response.content[0].text
def read_file(self, path: str) -> str:
"""Прочитать файл"""
full_path = self.workspace / path
return full_path.read_text()
def write_file(self, path: str, content: str) -> None:
"""Записать файл"""
full_path = self.workspace / path
full_path.parent.mkdir(parents=True, exist_ok=True)
full_path.write_text(content)
Инструменты: Python, anthropic-sdk, PyYAML, pathlib
1.2. Создать DocumentAgent
# platform/agents/document_agent.py
from .base_agent import BaseAgent
class DocumentAgent(BaseAgent):
"""
Агент для создания и обновления документации
ПЕРЕИСПОЛЬЗУЕТ существующие PROJECT.md как примеры
"""
def __init__(self, workspace_path: str):
super().__init__("DocumentAgent", workspace_path)
def execute(self, task: dict) -> dict:
"""
Выполнить задачу создания документации
task = {
"type": "create_project_md",
"project_name": "new-project",
"description": "...",
"tech_stack": ["Python", "Streamlit"]
}
"""
task_type = task.get("type")
if task_type == "create_project_md":
return self._create_project_md(task)
elif task_type == "update_changelog":
return self._update_changelog(task)
else:
return {"status": "error", "message": f"Unknown task type: {task_type}"}
def _create_project_md(self, task: dict) -> dict:
"""Создать PROJECT.md для нового проекта"""
# 1. Найти существующий PROJECT.md как пример
example_path = "projects/marketplace/design/PROJECT.md"
example = self.read_file(example_path)
# 2. Создать промпт для Claude
prompt = f"""
Создай PROJECT.md для нового проекта.
**Название проекта:** {task['project_name']}
**Описание:** {task['description']}
**Технологии:** {', '.join(task['tech_stack'])}
Используй следующий формат (из существующего проекта):
{example[:2000]} # Первые 2000 символов как пример
Создай полный PROJECT.md со всеми разделами.
"""
system = """Ты — агент документации платформы ЦИФРА.
Твоя задача — создавать качественную техническую документацию.
Используй существующие примеры и адаптируй их под новый проект."""
# 3. Вызвать Claude
content = self.call_claude(prompt, system)
# 4. Сохранить файл
output_path = f"projects/{task['project_name']}/design/PROJECT.md"
self.write_file(output_path, content)
return {
"status": "success",
"file": output_path,
"agent": self.name
}
def _update_changelog(self, task: dict) -> dict:
"""Обновить CHANGELOG.md"""
# Аналогично create_project_md
pass
Инструменты: Python, Claude API для генерации
1.3. Создать CodeAgent
# platform/agents/code_agent.py
from .base_agent import BaseAgent
from pathlib import Path
class CodeAgent(BaseAgent):
"""
Агент для генерации кода
ИСПОЛЬЗУЕТ Cascade Search для поиска существующих компонентов
"""
def __init__(self, workspace_path: str):
super().__init__("CodeAgent", workspace_path)
def execute(self, task: dict) -> dict:
"""
Выполнить задачу генерации кода
task = {
"type": "create_function",
"description": "форматирование цены",
"language": "python",
"output_path": "projects/myproject/utils/formatters.py"
}
"""
task_type = task.get("type")
if task_type == "create_function":
return self._create_function(task)
elif task_type == "create_module":
return self._create_module(task)
else:
return {"status": "error", "message": f"Unknown task type: {task_type}"}
def _create_function(self, task: dict) -> dict:
"""Создать функцию (с использованием Cascade Search)"""
# 1. CASCADE SEARCH — ищем существующее решение
search_result = self._cascade_search(task['description'])
if search_result['found']:
# Нашли готовое решение!
existing_code = self.read_file(search_result['path'])
prompt = f"""
Адаптируй существующую функцию под новую задачу.
**Задача:** {task['description']}
**Существующий код:**
{existing_code}
**Что нужно:**
1. Адаптировать функцию под новую задачу
2. Сохранить стиль и подход
3. Добавить docstring
Верни только код функции.
"""
code = self.call_claude(prompt, system="Ты — агент генерации кода. Адаптируй существующий код.")
result = {
"status": "success",
"source": "adapted",
"level": search_result['level'],
"original": search_result['path']
}
else:
# Не нашли — генерируем с нуля
prompt = f"""
Создай Python функцию для: {task['description']}
Требования:
- Чистый, читаемый код
- Type hints
- Docstring
- Обработка ошибок
Верни только код функции.
"""
code = self.call_claude(prompt, system="Ты — агент генерации кода.")
result = {
"status": "success",
"source": "generated",
"level": "L7"
}
# 2. Сохранить код
self.write_file(task['output_path'], code)
result['file'] = task['output_path']
result['agent'] = self.name
return result
def _cascade_search(self, description: str) -> dict:
"""
Cascade Search — поиск существующих решений
L1: Platform rules
L2: Registry
L3: Templates
L4: Components
L5: Projects
L6: Archive
L7: Generate (не нашли)
"""
# L3: Поиск в templates/
templates_path = self.workspace / "templates"
for template_dir in templates_path.rglob("*"):
if template_dir.is_file() and template_dir.suffix == ".py":
# Простой поиск по ключевым словам в имени файла
if any(word in template_dir.name.lower() for word in description.lower().split()):
return {
"found": True,
"level": "L3",
"path": str(template_dir.relative_to(self.workspace))
}
# L4: Поиск в components/
components_path = self.workspace / "components"
if components_path.exists():
for component_file in components_path.rglob("*.py"):
if any(word in component_file.name.lower() for word in description.lower().split()):
return {
"found": True,
"level": "L4",
"path": str(component_file.relative_to(self.workspace))
}
# L5: Поиск в существующих проектах
# ... аналогично
# Не нашли
return {"found": False}
Инструменты: Python, pathlib для файловой системы, Claude API
1.4. Создать GitAgent
# platform/agents/git_agent.py
from .base_agent import BaseAgent
import subprocess
class GitAgent(BaseAgent):
"""
Агент для работы с Git
"""
def __init__(self, workspace_path: str):
super().__init__("GitAgent", workspace_path)
def execute(self, task: dict) -> dict:
"""
Выполнить Git операцию
task = {
"type": "commit",
"message": "feat: добавлен новый проект",
"files": ["projects/new-project/"]
}
"""
task_type = task.get("type")
if task_type == "commit":
return self._commit(task)
elif task_type == "status":
return self._status()
else:
return {"status": "error", "message": f"Unknown task type: {task_type}"}
def _commit(self, task: dict) -> dict:
"""Создать Git коммит"""
# 1. Add files
for file_path in task.get('files', ['.']):
subprocess.run(
['git', 'add', file_path],
cwd=self.workspace,
check=True
)
# 2. Commit
subprocess.run(
['git', 'commit', '-m', task['message']],
cwd=self.workspace,
check=True
)
return {
"status": "success",
"message": task['message'],
"agent": self.name
}
def _status(self) -> dict:
"""Получить Git статус"""
result = subprocess.run(
['git', 'status', '--porcelain'],
cwd=self.workspace,
capture_output=True,
text=True
)
return {
"status": "success",
"output": result.stdout,
"agent": self.name
}
Инструменты: Python subprocess для Git команд
2.1. Создать AgentAPI
# platform/api/agent_api.py
from typing import Dict, Any
from platform.agents.base_agent import BaseAgent
class AgentAPI:
"""
Централизованный API для взаимодействия агентов
"""
def __init__(self, workspace_path: str):
self.workspace = workspace_path
self.agents: Dict[str, BaseAgent] = {}
def register_agent(self, agent: BaseAgent) -> None:
"""Зарегистрировать агента"""
self.agents[agent.name] = agent
print(f"✅ Agent registered: {agent.name}")
def call_agent(self, agent_name: str, task: dict) -> dict:
"""Вызвать агента для выполнения задачи"""
if agent_name not in self.agents:
return {
"status": "error",
"message": f"Agent not found: {agent_name}"
}
agent = self.agents[agent_name]
print(f"🤖 Calling {agent_name}...")
result = agent.execute(task)
print(f"✅ {agent_name} completed: {result['status']}")
return result
def get_agents(self) -> list:
"""Получить список зарегистрированных агентов"""
return list(self.agents.keys())
Инструменты: Python typing для type hints
2.2. Создать конфигурацию
# platform/config/agents.yaml
claude_api_key: ${ANTHROPIC_API_KEY} # Из переменной окружения
agents:
DocumentAgent:
enabled: true
description: "Создание и обновление документации"
CodeAgent:
enabled: true
description: "Генерация кода с использованием Cascade Search"
GitAgent:
enabled: true
description: "Работа с Git"
2.3. Создать bootstrap скрипт
# platform/bootstrap.py
from platform.agents.document_agent import DocumentAgent
from platform.agents.code_agent import CodeAgent
from platform.agents.git_agent import GitAgent
from platform.api.agent_api import AgentAPI
def bootstrap():
"""
Запуск минимальной системы из 3 агентов
"""
workspace = "/opt/claude-workspace"
# 1. Создать API
api = AgentAPI(workspace)
# 2. Создать и зарегистрировать агентов
doc_agent = DocumentAgent(workspace)
code_agent = CodeAgent(workspace)
git_agent = GitAgent(workspace)
api.register_agent(doc_agent)
api.register_agent(code_agent)
api.register_agent(git_agent)
print(f"\n✅ Bootstrap complete! Registered agents: {api.get_agents()}\n")
return api
if __name__ == "__main__":
api = bootstrap()
# Пример использования
result = api.call_agent("DocumentAgent", {
"type": "create_project_md",
"project_name": "test-project",
"description": "Test project for bootstrap",
"tech_stack": ["Python"]
})
print(f"\n📄 Result: {result}\n")
2.4. Тестирование
# tests/test_bootstrap.py
import pytest
from platform.bootstrap import bootstrap
def test_bootstrap():
"""Тест успешного запуска bootstrap"""
api = bootstrap()
# Проверяем, что все 3 агента зарегистрированы
agents = api.get_agents()
assert len(agents) == 3
assert "DocumentAgent" in agents
assert "CodeAgent" in agents
assert "GitAgent" in agents
def test_document_agent():
"""Тест DocumentAgent"""
api = bootstrap()
result = api.call_agent("DocumentAgent", {
"type": "create_project_md",
"project_name": "test-project",
"description": "Test",
"tech_stack": ["Python"]
})
assert result['status'] == 'success'
assert 'file' in result
def test_code_agent():
"""Тест CodeAgent"""
api = bootstrap()
result = api.call_agent("CodeAgent", {
"type": "create_function",
"description": "форматирование цены",
"language": "python",
"output_path": "test_output.py"
})
assert result['status'] == 'success'
Инструменты: pytest для тестирования
✅ 3 агента работают (DocumentAgent, CodeAgent, GitAgent)
✅ AgentAPI позволяет вызывать агентов
✅ Все тесты проходят
✅ Bootstrap скрипт успешно запускается
✅ Создан Git коммит с результатами
Команда проверки:
cd /opt/claude-workspace
python platform/bootstrap.py
pytest tests/test_bootstrap.py
Цель: Использовать 3 существующих агента для создания новых агентов.
Длительность: 2-3 дня
Усилия: 3 агента создают 3 новых (~800 строк, автоматически)
Существующие: DocumentAgent, CodeAgent, GitAgent
Новые зависимости: pytest, docker-sdk (для DeployAgent)
Подход: Самосоздание через AgentAPI
3.1. Написать спецификацию ProjectAgent
# specs/project_agent_spec.py
PROJECT_AGENT_SPEC = {
"name": "ProjectAgent",
"description": "Управление проектами — создание, обновление, архивирование",
"methods": [
{
"name": "create_project",
"params": ["project_name", "template", "description"],
"returns": "project_path"
},
{
"name": "archive_project",
"params": ["project_name"],
"returns": "archive_path"
},
{
"name": "list_projects",
"params": [],
"returns": "projects_list"
}
],
"template": "platform/agents/base_agent.py"
}
3.2. Использовать CodeAgent для генерации
# platform/create_project_agent.py
from platform.bootstrap import bootstrap
def create_project_agent():
"""Создать ProjectAgent используя CodeAgent"""
api = bootstrap()
# 1. Сгенерировать код ProjectAgent
result = api.call_agent("CodeAgent", {
"type": "create_module",
"description": """
Создай ProjectAgent класс, который наследуется от BaseAgent.
Методы:
- create_project(project_name, template, description) — создать проект из шаблона
- archive_project(project_name) — архивировать проект
- list_projects() — список проектов
Используй существующий BaseAgent как основу.
""",
"template_path": "platform/agents/base_agent.py",
"output_path": "platform/agents/project_agent.py"
})
print(f"✅ ProjectAgent created: {result}")
# 2. Создать документацию
doc_result = api.call_agent("DocumentAgent", {
"type": "create_agent_docs",
"agent_name": "ProjectAgent",
"output_path": "platform/docs/ProjectAgent.md"
})
# 3. Создать тесты
test_result = api.call_agent("CodeAgent", {
"type": "create_test",
"module": "platform.agents.project_agent",
"output_path": "tests/test_project_agent.py"
})
# 4. Git commit
api.call_agent("GitAgent", {
"type": "commit",
"message": "feat: добавлен ProjectAgent (создан через CodeAgent)",
"files": [
"platform/agents/project_agent.py",
"platform/docs/ProjectAgent.md",
"tests/test_project_agent.py"
]
})
return result
if __name__ == "__main__":
create_project_agent()
Инструменты: Существующие агенты через AgentAPI
Аналогично ProjectAgent, но через тот же процесс:
1. CodeAgent генерирует код TestAgent
2. DocumentAgent создаёт документацию
3. CodeAgent создаёт тесты для TestAgent
4. GitAgent делает коммит
Реализация:
# platform/create_test_agent.py
from platform.bootstrap import bootstrap
def create_test_agent():
"""Создать TestAgent используя CodeAgent"""
api = bootstrap()
result = api.call_agent("CodeAgent", {
"type": "create_module",
"description": """
Создай TestAgent класс для автоматического тестирования.
Методы:
- run_tests(project_name) — запустить pytest для проекта
- create_test(module_path, output_path) — создать тест для модуля
- check_coverage(project_name) — проверить покрытие тестами
""",
"template_path": "platform/agents/base_agent.py",
"output_path": "platform/agents/test_agent.py"
})
# Документация, тесты, Git — аналогично ProjectAgent
return result
✅ ProjectAgent создан и работает
✅ TestAgent создан и работает
✅ Оба агента созданы ЧЕРЕЗ существующие агенты (не вручную!)
✅ Все новые агенты покрыты тестами
✅ Git история показывает автоматическое создание
Команда проверки:
python platform/create_project_agent.py
python platform/create_test_agent.py
pytest tests/
Цель: Создать центральный агент-координатор.
Длительность: 1-2 дня
Усилия: ~400 строк (CentralAgent + workflow engine)
Координация: Python asyncio (опционально)
Workflow: Простая FSM (Finite State Machine)
Storage: YAML для хранения состояний
Logging: Python logging + файлы
5.1. Создать CentralAgent
# platform/agents/central_agent.py
from .base_agent import BaseAgent
from platform.api.agent_api import AgentAPI
class CentralAgent(BaseAgent):
"""
Центральный координирующий агент
Управляет workflow и делегирует задачи другим агентам
"""
def __init__(self, workspace_path: str, agent_api: AgentAPI):
super().__init__("CentralAgent", workspace_path)
self.api = agent_api
def execute(self, task: dict) -> dict:
"""
Выполнить задачу верхнего уровня
task = {
"type": "create_new_project",
"project_name": "my-app",
"template": "streamlit-mvp-v1",
"description": "..."
}
"""
if task['type'] == 'create_new_project':
return self._create_new_project_workflow(task)
# ... другие типы задач
def _create_new_project_workflow(self, task: dict) -> dict:
"""
Workflow создания нового проекта
Задачи:
1. ProjectAgent — создать структуру проекта
2. DocumentAgent — создать PROJECT.md
3. CodeAgent — сгенерировать стартовый код
4. TestAgent — создать тесты
5. GitAgent — сделать коммит
"""
results = []
# Шаг 1: Создать проект
result1 = self.api.call_agent("ProjectAgent", {
"type": "create_project",
"project_name": task['project_name'],
"template": task['template']
})
results.append(result1)
# Шаг 2: Создать документацию
result2 = self.api.call_agent("DocumentAgent", {
"type": "create_project_md",
"project_name": task['project_name'],
"description": task['description']
})
results.append(result2)
# Шаг 3: Сгенерировать код
result3 = self.api.call_agent("CodeAgent", {
"type": "create_app",
"project_name": task['project_name'],
"template": task['template']
})
results.append(result3)
# Шаг 4: Создать тесты
result4 = self.api.call_agent("TestAgent", {
"type": "create_tests",
"project_name": task['project_name']
})
results.append(result4)
# Шаг 5: Git commit
result5 = self.api.call_agent("GitAgent", {
"type": "commit",
"message": f"feat: создан проект {task['project_name']}",
"files": [f"projects/{task['project_name']}/"]
})
results.append(result5)
return {
"status": "success",
"workflow": "create_new_project",
"steps": len(results),
"results": results
}
5.2. Обновить AgentAPI
Добавить метод для регистрации CentralAgent и workflow.
5.3. Создать CLI интерфейс
# platform/cli.py
import click
from platform.bootstrap import bootstrap
from platform.agents.central_agent import CentralAgent
@click.group()
def cli():
"""Платформа ЦИФРА — CLI"""
pass
@cli.command()
@click.option('--name', required=True, help='Название проекта')
@click.option('--template', required=True, help='Шаблон проекта')
@click.option('--description', required=True, help='Описание')
def create_project(name, template, description):
"""Создать новый проект"""
api = bootstrap()
central = CentralAgent("/opt/claude-workspace", api)
result = central.execute({
"type": "create_new_project",
"project_name": name,
"template": template,
"description": description
})
click.echo(f"✅ Проект создан: {result}")
if __name__ == '__main__':
cli()
Инструменты: Click для CLI, Python
✅ CentralAgent работает и координирует агентов
✅ Workflow "создание проекта" работает end-to-end
✅ CLI интерфейс позволяет вызывать CentralAgent
✅ Все шаги workflow логируются
Команда проверки:
python platform/cli.py create-project --name test --template streamlit-mvp-v1 --description "Test"
Цель: Добавить агентов для полного цикла разработки.
Длительность: 3-5 дней
Усилия: ~1200 строк (3 новых агента + интеграции)
DeployAgent:
- Docker SDK для Python
- SSH через paramiko
- systemd управление
MonitorAgent:
- psutil для мониторинга
- requests для health checks
- SQLite для хранения метрик
BugfixAgent:
- pytest для воспроизведения
- Git для анализа истории
- Claude API для анализа багов
✅ Все 9 агентов работают
✅ Полный цикл: создание → деплой → мониторинг → багфикс
✅ Интеграция с существующей инфраструктурой (Docker, SSH)
Цель: Создать MetaAgent — агент, улучшающий саму платформу.
Длительность: 3-5 дней
Усилия: ~600 строк (MetaAgent + аналитика)
Аналитика: SQLite для хранения метрик
Анализ кода: AST для Python
Улучшения: Claude API для рефакторинга
Testing: pytest для проверки улучшений
# platform/agents/meta_agent.py
class MetaAgent(BaseAgent):
"""
Агент самосовершенствования платформы
"""
def execute(self, task: dict) -> dict:
if task['type'] == 'analyze_performance':
return self._analyze_performance()
elif task['type'] == 'suggest_improvements':
return self._suggest_improvements()
elif task['type'] == 'apply_improvement':
return self._apply_improvement(task)
def _analyze_performance(self) -> dict:
"""Анализ производительности агентов"""
# 1. Собрать метрики из логов
metrics = self._collect_metrics()
# 2. Найти узкие места
bottlenecks = self._find_bottlenecks(metrics)
# 3. Использовать Claude для анализа
prompt = f"""
Проанализируй производительность агентов:
Метрики: {metrics}
Узкие места: {bottlenecks}
Предложи 3 конкретных улучшения.
"""
suggestions = self.call_claude(prompt)
return {
"status": "success",
"metrics": metrics,
"suggestions": suggestions
}
✅ MetaAgent работает
✅ Платформа собирает метрики
✅ MetaAgent предлагает улучшения
✅ Проверено хотя бы 1 автоматическое улучшение
Цель: Добавить голосовой интерфейс.
Длительность: 5-7 дней
Усилия: ~1500 строк (VoiceAgent + интеграции)
Speech-to-Text: OpenAI Whisper API
Text-to-Speech: ElevenLabs API / Google TTS
Audio: PyAudio для записи
NLU: Claude API для понимания команд
# platform/agents/voice_agent.py
import openai
from elevenlabs import generate, play
class VoiceAgent(BaseAgent):
"""
Агент голосового взаимодействия
"""
def execute(self, task: dict) -> dict:
if task['type'] == 'listen_and_execute':
return self._listen_and_execute()
def _listen_and_execute(self) -> dict:
# 1. Записать аудио
audio = self._record_audio()
# 2. STT — распознать речь
text = self._speech_to_text(audio)
print(f"🎤 Услышал: {text}")
# 3. NLU — понять команду
command = self._understand_command(text)
# 4. Выполнить через CentralAgent
result = self.api.call_agent("CentralAgent", command)
# 5. TTS — озвучить результат
response_text = f"Готово! {result['status']}"
self._text_to_speech(response_text)
return result
def _speech_to_text(self, audio_file: str) -> str:
"""Whisper API"""
with open(audio_file, 'rb') as f:
transcript = openai.Audio.transcribe("whisper-1", f)
return transcript['text']
def _text_to_speech(self, text: str) -> None:
"""ElevenLabs TTS"""
audio = generate(text=text, voice="Adam")
play(audio)
✅ VoiceAgent работает
✅ Можно создать проект голосом
✅ Платформа озвучивает результаты
✅ NLU понимает команды на русском
День 1-2: ФАЗА 0 — Bootstrap (DocumentAgent, CodeAgent, GitAgent)
День 3-4: ФАЗА 1 — Self-Creation (ProjectAgent, TestAgent)
День 5-6: ФАЗА 2 — Central Coordination (CentralAgent, CLI)
День 7-11: ФАЗА 3 — Full Lifecycle (DeployAgent, MonitorAgent, BugfixAgent)
День 12-16: ФАЗА 4 — Meta-Improvement (MetaAgent)
День 17-23: ФАЗА 5 — Voice Interface (VoiceAgent)
ИТОГО: 23 дня до полной платформы
Core:
- Python 3.11+
- Claude API (anthropic-sdk)
- Git
Infrastructure:
- Docker SDK
- SSH (paramiko)
- systemd
Development:
- pytest
- Playwright
- Click (CLI)
Voice:
- Whisper API
- ElevenLabs API
- PyAudio
Storage:
- SQLite
- YAML
- File System
CentralAgent (координатор)
↓
AgentAPI (hub)
↓
┌─────────────┬─────────────┬─────────────┬─────────────┐
│ DocumentAgent│ CodeAgent │ GitAgent │ ProjectAgent│
├─────────────┼─────────────┼─────────────┼─────────────┤
│ TestAgent │ DeployAgent │ MonitorAgent│ BugfixAgent │
├─────────────┼─────────────┼─────────────┼─────────────┤
│ MetaAgent │ VoiceAgent │ ... │ ... │
└─────────────┴─────────────┴─────────────┴─────────────┘
ФАЗА 0: ~650 строк (ручная разработка)
ФАЗА 1: ~800 строк (автоматически через агентов)
ФАЗА 2: ~400 строк
ФАЗА 3: ~1200 строк
ФАЗА 4: ~600 строк
ФАЗА 5: ~1500 строк
ИТОГО: ~5,150 строк кода
✅ Платформа создаёт проекты голосом
✅ Полный цикл: идея → production → мониторинг → багфикс
✅ Агенты создают других агентов
✅ Платформа улучшает сама себя (MetaAgent)
✅ Все агенты покрыты тестами
✅ Cascade Search экономит 80%+ токенов
✅ Git история показывает всю эволюцию
✅ CLI и Voice интерфейсы работают
✅ Документация актуальна
✅ Код читаемый и поддерживаемый
✅ Минимум зависимостей
✅ Безопасность (secrets management)
# 1. Перейти в workspace
cd /opt/claude-workspace
# 2. Создать структуру для Фазы 0
mkdir -p platform/{agents,api,config,utils}
touch platform/agents/{__init__.py,base_agent.py,document_agent.py,code_agent.py,git_agent.py}
touch platform/api/{__init__.py,agent_api.py}
touch platform/config/agents.yaml
# 3. Скопировать код из этого документа в файлы
# 4. Установить зависимости
pip install anthropic pyyaml pytest click
# 5. Запустить bootstrap
python platform/bootstrap.py
# 6. Запустить тесты
pytest tests/
# 7. Начать Фазу 1!
python platform/create_project_agent.py
components/ — переиспользуемые компонентыtemplates/ — шаблоны проектовtests/library/ — примеры тестовexport ANTHROPIC_API_KEY="sk-ant-..." # Claude API
export OPENAI_API_KEY="sk-..." # Whisper (Фаза 5)
export ELEVENLABS_API_KEY="..." # TTS (Фаза 5)
Версия: 1.0.0
Дата создания: 2025-11-10
Автор: Claude Code
Статус: Production Ready Blueprint
Следующий шаг: Начать Фазу 0 — Bootstrap Foundation!