Skip to content
Back to search

eion

Shared Memory Storage for Multi-Agent Systems

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/eiondb--eion/badge.svg)](/listings/eiondb--eion)

HTML

<a href="/listings/eiondb--eion"><img src="/api/listings/eiondb--eion/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Prerequisites

- **Docker & Docker Compose**: For PostgreSQL and Neo4j - **Go 1.21+**: For the Eion server - **Python 3.13+**: For knowledge extraction services

1. Clone and Setup

git clone <repo>
cd eion

2. Start Database Services

# Start all required databases (PostgreSQL + Neo4j)
docker-compose up -d

# Verify databases are ready
docker-compose ps

3. Setup Database Extensions and Tables

# Enable the pgvector extension (required for embeddings)
docker exec eion_postgres psql -U eion -d eion -c "CREATE EXTENSION IF NOT EXISTS vector;"

# Run main orchestrator migrations (includes sessions table)
docker exec -i eion_postgres psql -U eion -d eion < database_setup.sql

4. Install Python Dependencies

# Create virtual environment
python3 -m venv .venv
source .venv/bin/activate  # On Windows: .venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

5. Build and Run Eion Server

# Build the server
go build -o eion-server ./cmd/eion-server

# Run the server
./eion-server

6. Verify Setup

# Check server health
curl http://localhost:8080/health

# Expected response:
# {"status":"healthy","timestamp":"2024-12-19T10:30:00Z","services":{"database":"healthy","embedding":"healthy"}}

7. Access the Register Console

Navigate to the Register Console for easy cluster management:

http://localhost:8080/console/

**⚠️ Important**: Include the trailing slash `/` in the URL.

Console Features

**Agent Registration Tab:** - Simple form-based agent registration with automatic ID generation - Support for different permission levels (read, read-write, full CRUD) - Real-time registration status feedback - View all registered agents in a table

**Monitoring Tab:** - Real-time agent status and system monitoring - View active sessions and users (coming soon) - Refresh functionality for live updates

**Resources Tab:** - Copy-paste ready HTTP API examples with your current configuration - MCP integration snippets (when MCP is enabled) - Quick start guide for developers - Copy-to-clipboard functionality for easy integration

Using the Console

1. **Register an Agent:** - Go to "Register Agents" tab - Fill in name, description, and permissions - Click "Register Agent" - Agent appears in the table below

2. **Monitor Activity:** - Switch to "Monitoring" tab - View agent status and system health - Use refresh button for updates

3. **Get Integration Examples:** - Visit "Resources" tab - Copy HTTP API examples with your server details - Use MCP configuration if MCP is enabled

Configuration Display

The console automatically shows: - Cluster API key for authentication - Server host and port - MCP and Numa integration status - Neo4j connection details (when enabled)

Styling

The console uses Eion's brand colors: - **Navy Blue** background with **Cream** text - Responsive design for desktop and mobile - Consistent with the main Eion website styling

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 363 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <div align="center">
  2. <img src="assets/eion-navy.png#gh-light-mode-only" alt="Eion Logo" width="200" height="200">
  3. <img src="assets/eion-cream.png#gh-dark-mode-only" alt="Eion Logo" width="200" height="200">
  4. <h1 style="border-bottom: none; margin-bottom: 0;">Eion</h1>
  5. *Connecting AI agents through shared memory and collaborative intelligence.*
  6. ![Version](https://img.shields.io/badge/Version-v0.1.4-green)
  7. [![License: AGPL v3](https://img.shields.io/badge/License-AGPL_v3-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)
  8. [![Discord](https://img.shields.io/badge/Discord-7289DA?style=flat-square&logo=discord&logoColor=white)](https://discord.gg/mMNckGYVbq)
  9. </div>
  10. <div align="center">
  11. <img src="assets/eion-demo.gif" alt="Eion Demo" width="90%" />
  12. </div>
  13. &nbsp;
  14. **Eion** is a shared memory storage that provides unified knowledge graph capabilities for multi-agent systems, adapting to different AI deployment scenarios from single LLM applications to complex multi-agency systems.
  15. ### 1. LLM Application
  16. ```
  17. User ↔ LLM Application → Eion (context storage)
  18. ```
  19. ### 2. AI Agent Application
  20. ```
  21. Business Logic ↔ AI Agent → Eion (memory + knowledge graph)
  22. ```
  23. ### 3. Agency (Multi-Agent) Systems
  24. #### 3a. Sequential Agency
  25. ```
  26. Agent A → context → Agent B → context → Agent C
  27. ↓ ↓ ↓
  28. Eion ← shared memory & knowledge → Eion
  29. ```
  30. #### 3b. Concurrent Live Agency (WIP)
  31. ```
  32. Agent A ──┐
  33. ├── shared live context ← Eion (live sync + notifications)
  34. Agent B ──┤
  35. │
  36. Agent C ──┘
  37. ```
  38. ### 4. External Guest Agent Access
  39. ```
  40. Internal Agency: Agent A ↔ Agent B → Eion ← External Agent C (guest)
  41. ↑
  42. (controlled access)
  43. ```
  44. ## Quick Start
  45. ### Prerequisites
  46. - **Docker & Docker Compose**: For PostgreSQL and Neo4j
  47. - **Go 1.21+**: For the Eion server
  48. - **Python 3.13+**: For knowledge extraction services
  49. ### 1. Clone and Setup
  50. ```bash
  51. git clone <repo>
  52. cd eion
  53. ```
  54. ### 2. Start Database Services
  55. ```bash
  56. # Start all required databases (PostgreSQL + Neo4j)
  57. docker-compose up -d
  58. # Verify databases are ready
  59. docker-compose ps
  60. ```
  61. ### 3. Setup Database Extensions and Tables
  62. ```bash
  63. # Enable the pgvector extension (required for embeddings)
  64. docker exec eion_postgres psql -U eion -d eion -c "CREATE EXTENSION IF NOT EXISTS vector;"
  65. # Run main orchestrator migrations (includes sessions table)
  66. docker exec -i eion_postgres psql -U eion -d eion < database_setup.sql
  67. ```
  68. ### 4. Install Python Dependencies
  69. ```bash
  70. # Create virtual environment
  71. python3 -m venv .venv
  72. source .venv/bin/activate # On Windows: .venv\Scripts\activate
  73. # Install dependencies
  74. pip install -r requirements.txt
  75. ```
  76. ### 5. Build and Run Eion Server
  77. ```bash
  78. # Build the server
  79. go build -o eion-server ./cmd/eion-server
  80. # Run the server
  81. ./eion-server
  82. ```
  83. ### 6. Verify Setup
  84. ```bash
  85. # Check server health
  86. curl http://localhost:8080/health
  87. # Expected response:
  88. # {"status":"healthy","timestamp":"2024-12-19T10:30:00Z","services":{"database":"healthy","embedding":"healthy"}}
  89. ```
  90. ### 7. Access the Register Console
  91. Navigate to the Register Console for easy cluster management:
  92. ```
  93. http://localhost:8080/console/
  94. ```
  95. **⚠️ Important**: Include the trailing slash `/` in the URL.
  96. #### Console Features
  97. **Agent Registration Tab:**
  98. - Simple form-based agent registration with automatic ID generation
  99. - Support for different permission levels (read, read-write, full CRUD)
  100. - Real-time registration status feedback
  101. - View all registered agents in a table
  102. **Monitoring Tab:**
  103. - Real-time agent status and system monitoring
  104. - View active sessions and users (coming soon)
  105. - Refresh functionality for live updates
  106. **Resources Tab:**
  107. - Copy-paste ready HTTP API examples with your current configuration
  108. - MCP integration snippets (when MCP is enabled)
  109. - Quick start guide for developers
  110. - Copy-to-clipboard functionality for easy integration
  111. #### Using the Console
  112. 1. **Register an Agent:**
  113. - Go to "Register Agents" tab
  114. - Fill in name, description, and permissions
  115. - Click "Register Agent"
  116. - Agent appears in the table below
  117. 2. **Monitor Activity:**
  118. - Switch to "Monitoring" tab
  119. - View agent status and system health
  120. - Use refresh button for updates
  121. 3. **Get Integration Examples:**
  122. - Visit "Resources" tab
  123. - Copy HTTP API examples with your server details
  124. - Use MCP configuration if MCP is enabled
  125. #### Configuration Display
  126. The console automatically shows:
  127. - Cluster API key for authentication
  128. - Server host and port
  129. - MCP and Numa integration status
  130. - Neo4j connection details (when enabled)
  131. #### Styling
  132. The console uses Eion's brand colors:
  133. - **Navy Blue** background with **Cream** text
  134. - Responsive design for desktop and mobile
  135. - Consistent with the main Eion website styling
  136. ## Architecture
  137. Eion provides a unified API that combines:
  138. - **Memory Storage**: PostgreSQL with pgvector for conversation history and semantic search
  139. - **Knowledge Graph**: Neo4j with in-house extraction for temporal knowledge storage
  140. - **Real Embeddings**: `all-MiniLM-L6-v2` model (384 dimensions) using sentence-transformers - production-ready embeddings
  141. - **Knowledge Extraction**: In-house extraction service for entity/relationship extraction
  142. ## MCP Server Integration
  143. Eion includes a built-in **Model Context Protocol (MCP) Server** that enables seamless agent integration through standardized tool interfaces.
  144. ### What MCP Provides
  145. The MCP server exposes Eion's Session-level API as MCP tools, allowing AI agents to:
  146. - Store and retrieve conversation memories
  147. - Perform semantic search across stored conversations
  148. - Create and manage knowledge entries
  149. - Search through extracted knowledge graphs
  150. ### Available MCP Tools
  151. **Memory Tools (4):**
  152. - `get_memory` - Retrieve conversation history with filters
  153. - `add_memory` - Store new conversation messages
  154. - `search_memory` - Semantic search in conversation history
  155. - `delete_memory` - Remove conversation data
  156. **Knowledge Tools (4):**
  157. - `search_knowledge` - Find relevant extracted knowledge
  158. - `create_knowledge` - Add new knowledge entries
  159. - `update_knowledge` - Modify existing knowledge
  160. - `delete_knowledge` - Remove knowledge entries
  161. ### Agent Integration
  162. **Direct MCP Client (Recommended):**
  163. ```python
  164. from mcp import ClientSession, StdioServerParameters
  165. from mcp.client.stdio import stdio_client
  166. # Connect to Eion MCP server
  167. server_params = StdioServerParameters(
  168. command="python",
  169. args=["-m", "internal.mcp.server"],
  170. env={"EION_BASE_URL": "http://localhost:8080"}
  171. )
  172. async with stdio_client(server_params) as (read, write):
  173. async with ClientSession(read, write) as session:
  174. await session.initialize()
  175. # Use tools with agent credentials
  176. result = await session.call_tool("add_memory", {
  177. "session_id": "agent_session_123",
  178. "agent_id": "my_registered_agent",
  179. "user_id": "end_user_456",
  180. "messages": [{"role": "user", "content": "Hello!"}]
  181. })
  182. ```
  183. **LangChain Integration:**
  184. ```python
  185. from langchain_mcp_tools import convert_mcp_to_langchain_tools
  186. mcp_servers = {
  187. "eion": {
  188. "command": "python",
  189. "args": ["-m", "internal.mcp.server"],
  190. "env": {"EION_BASE_URL": "http://localhost:8080"}
  191. }
  192. }
  193. tools, cleanup = await convert_mcp_to_langchain_tools(mcp_servers)
  194. # Use tools with LangChain agents
  195. ```
  196. **Claude Desktop Integration:**
  197. Add to `claude_desktop_config.json`:
  198. ```json
  199. {
  200. "mcpServers": {
  201. "eion": {
  202. "command": "python",
  203. "args": ["-m", "internal.mcp.server"],
  204. "env": {"EION_BASE_URL": "http://localhost:8080"},
  205. "cwd": "/path/to/eion"
  206. }
  207. }
  208. }
  209. ```
  210. ### Authentication
  211. All MCP tools require agent authentication:
  212. - `session_id` - Unique session identifier for the conversation
  213. - `agent_id` - Registered agent ID (obtain via Developer API)
  214. - `user_id` - End user ID that the agent serves
  215. Agents must be registered via the Developer API before using MCP tools:
  216. ```bash
  217. curl -X POST http://localhost:8080/cluster/v1/agents \
  218. -H "Content-Type: application/json" \
  219. -d '{"name": "My Agent", "capabilities": ["memory", "knowledge"]}'
  220. ```
  221. ### MCP Configuration
  222. MCP server settings in `eion.yaml`:
  223. ```yaml
  224. mcp:
  225. enabled: true # Enable MCP server
  226. port: 8081 # MCP server port
  227. python_path: ".venv/bin/python" # Python executable path
  228. log_level: "INFO" # Logging level
  229. timeout: 30 # Request timeout (seconds)
  230. ```
  231. The MCP server is embedded within the Eion server process and requires no separate deployment.
  232. ## Configuration
  233. Create `eion.yaml` (optional - defaults work out of the box):
  234. ```yaml
  235. common:
  236. http:
  237. host: "0.0.0.0"
  238. port: 8080
  239. postgres:
  240. user: "eion"
  241. password: "eion_pass"
  242. host: "localhost"
  243. port: 5432
  244. database: "eion"
  245. # Neo4j Configuration (Required)
  246. numa:
  247. neo4j:
  248. uri: "bolt://localhost:7687"
  249. username: "neo4j"
  250. password: "password"
  251. database: "neo4j"
  252. # MCP Server Configuration (Optional)
  253. mcp:
  254. enabled: true # Enable MCP server
  255. port: 8081 # MCP server port
  256. python_path: ".venv/bin/python" # Path to Python executable
  257. log_level: "INFO" # MCP server log level
  258. timeout: 30 # Request timeout in seconds
  259. # Register Console Configuration (Optional)
  260. console:
  261. enabled: true # Enable Register Console (default: true)
  262. ```
  263. ## Additional Configuration
  264. For production deployments, you may want to customize the database settings in `docker-compose.yml` or create your own configuration.
  265. Or use the automated setup script:
  266. ```bash
  267. # One-command setup (includes database startup, Python env, and server build)
  268. ./setup.sh
  269. # Then start the server
  270. ./eion-server
  271. ```
  272. ---
  273. <div align="center">
  274. <img src="assets/eion-navy.png#gh-light-mode-only" alt="Eion Logo" width="50" height="50">
  275. <img src="assets/eion-cream.png#gh-dark-mode-only" alt="Eion Logo" width="50" height="50">
  276. </div>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.