This video introduces EKA (Editor Code Assistant), a new open-source project designed to standardize AI-powered coding assistance across various code editors. Inspired by the success of the Language Server Protocol (LSP), EKA operates as a central server that communicates with editors (currently Emacs and VS Code are well-supported) and Large Language Models (LLMs).
The speaker explains the rationale for EKA, highlighting the desire to avoid fragmented AI integrations and provide a consistent user experience. The choice of Clojure for EKA's development is justified by the speaker's prior experience with LSP implementations, performance benefits from GraalVM compilation, and superior asynchronous programming capabilities. The core functionality demonstrated includes interactive chat, context provision to LLMs, and the use of built-in and custom tools (MCPs) for tasks like file system operations and code modification. A key concept, the "LLM loop," is illustrated, showing how EKA orchestrates a series of LLM calls and tool executions to fulfill complex requests, such as automatically generating unit tests. The project aims to become a comprehensive, editor-agnostic solution for AI-assisted coding, with ongoing development and a call for community contributions.
Summarizing EKA: An Editor-Agnostic AI Code Assistant
0:00 Project Introduction: The speaker introduces EKA (Editor Code Assistant), a new project aiming to standardize AI-powered coding assistance.
0:11 Rationale for EKA: Driven by the need for a unified AI tool for code across various editors (Emacs, VS Code, IntelliJ), similar to how LSP standardizes programming language support, avoiding fragmented and inconsistent AI integrations.
0:42 LSP Inspiration: EKA is modeled after the Language Server Protocol (LSP), which successfully standardized language features across multiple editors by using a central server.
4:30 EKA Architecture: EKA acts as a server mediating between code editors and Large Language Models (LLMs), providing features like chat and code completion. The server handles complex logic, allowing editors to have minimal client-side code.
5:13 Why a New Protocol (Not LSP): LSP is too generic for AI-specific features like chat and advanced code completion, making a dedicated AI protocol more suitable and universally supportable across editors.
5:59 Why Clojure: The speaker chose Clojure due to their experience with Clojure LSP, ease of setup, fast startup times and improved performance with GraalVM compilation, simpler asynchronous programming (handling LLM calls), and faster development time.
9:31 Getting Started & Configuration: EKA integrates as an editor plugin/extension. Users configure LLM models (e.g., OpenAI, Anthropic, Llama, custom company providers) and their API keys via a JSON file.
12:15 LLM Behaviors (Modes): EKA supports two main LLM behaviors: "Plan" (LLM researches and proposes changes for user approval) and "Agent" (LLM directly executes changes).
13:17 Built-in Tools (MCPs): EKA provides LLMs with "built-in tools" (called MCPs) to interact with the file system (list, read, edit, move files) and perform searches. Language-specific MCPs (e.g., Clojure MCP) offer additional capabilities like understanding project file structures.
14:17 Context is Key: LLM communication quality relies on the context provided. EKA automatically includes the current file, project repo map, and allows users to add additional context (e.g., readme files) or leverage MCP-provided resources.
17:26 Custom Commands & Prompts: Users can create custom commands (e.g., "explain tag") and utilize MCP-provided prompts (pre-defined text snippets) to streamline specific tasks.
18:27 "Prompt Show" Feature: This command allows users to view the exact full input sent to the LLM, including system instructions, context, and tool definitions, for transparency and debugging.
19:48 Unit Test Generation Demo: The speaker demonstrates EKA's ability to generate unit tests for a Clojure function. The LLM intelligently followed project coding standards and used file editing/running tools, even self-correcting an outdated file state issue.
24:56 Cost Monitoring: The EKA interface displays the cost of the last LLM message and the total conversation cost in USD.
27:55 The LLM Loop Explanation: The speaker details how EKA uses an "LLM loop." An initial user query can trigger the LLM to call a tool (e.g., list files). EKA executes the tool, sends the tool's output back to the LLM, and the LLM continues reasoning and potentially calling more tools in an iterative process. This loop explains why complex tasks can lead to higher LLM costs due to multiple interactions.
35:59 Future Plans & Contribution: Future development includes adding more advanced features (e.g., "roots" like Claude and Cursor), expanding support to major editors like IntelliJ, and seeking community feedback and contributions. The project is available on eka.dev and GitHub.