@youngkang/n8n-nodes-seedos 0.1.0

package/README.md

@@ -0,0 +1,178 @@
+# SeedOS n8n Custom Node
+
+SeedOS Memory System을 n8n 워크플로우에 통합하는 Custom Node입니다.
+
+## 🎯 기능
+
+- **Store Memory**: 메모리 블록 저장
+- **Search Memory**: 의미 기반 메모리 검색
+- **Query with AI**: Thalamic AI를 사용한 쿼리
+- **Create Identity**: AI Identity 생성
+- **Verify Proof**: Merkle Proof 검증
+
+## 📦 설치
+
+### n8n에서 설치
+
+```bash
+# n8n 커뮤니티 노드로 설치
+npm install @seedos/n8n-nodes-seedos
+```
+
+또는 n8n UI에서:
+1. Settings → Community Nodes
+2. "Install community node" 클릭
+3. `@seedos/n8n-nodes-seedos` 입력
+4. Install 클릭
+
+## 🚀 빠른 시작
+
+### 1. SeedOS 서버 준비
+
+```bash
+# Docker로 실행
+docker-compose up -d
+
+# 또는 로컬에서 실행
+uvicorn app.api:app --reload
+```
+
+### 2. n8n에서 노드 사용
+
+1. 워크플로우에 "SeedOS" 노드 추가
+2. Credentials 설정:
+   - **API Key**: `your-secret-api-key-here` (또는 설정한 키)
+   - **Base URL**: `http://localhost:8000`
+3. Operation 선택 (Store, Search, Query, Identity, Proof)
+4. 파라미터 입력 및 실행
+
+## 📋 Operations
+
+### Store Memory
+메모리 블록을 저장합니다.
+
+**파라미터**:
+- `layer`: 메모리 레이어 (예: "memory")
+- `type`: 블록 타입 (예: "event")
+- `payload`: 저장할 데이터 (JSON 객체)
+
+**예시**:
+```json
+{
+  "layer": "memory",
+  "type": "event",
+  "payload": {
+    "text": "Important meeting notes",
+    "date": "2026-01-21"
+  }
+}
+```
+
+### Search Memory
+의미 기반으로 메모리를 검색합니다.
+
+**파라미터**:
+- `query`: 검색 쿼리
+- `topK`: 반환할 결과 수 (기본: 5)
+
+### Query with AI
+Thalamic AI를 사용하여 메모리 기반 응답을 생성합니다.
+
+**파라미터**:
+- `question`: 질문
+- `llmProvider`: LLM 제공업체 (openai, anthropic)
+- `model`: 모델 이름 (예: "gpt-4")
+
+**주의**: LLM API Key가 SeedOS 서버에 설정되어 있어야 합니다.
+
+### Create Identity
+AI Identity를 생성합니다.
+
+**파라미터**:
+- `name`: Identity 이름 (영문, 숫자, -, _만 사용)
+- `purpose`: 목적 (최소 10자)
+- `coreValues`: 핵심 가치 (comma-separated)
+- `role`: 역할 (선택)
+
+### Verify Proof
+Merkle Proof를 검증합니다.
+
+**파라미터**:
+- `address`: 블록 주소 (MMP 형식)
+- `leafIndex`: 리프 인덱스
+- `leaves`: Merkle tree leaves (JSON 배열)
+- `leafValue`: 검증할 리프 값
+
+## 📚 워크플로우 템플릿
+
+5개의 워크플로우 템플릿이 제공됩니다:
+
+1. **Simple Memory Storage** - 기본 메모리 저장
+2. **Semantic Memory Search** - 의미 기반 검색
+3. **AI Memory Assistant** - AI 어시스턴트
+4. **Identity Management** - Identity 관리
+5. **Complete Memory Loop** - 완전한 메모리 루프
+
+템플릿은 `workflow_templates/` 디렉토리에 있으며, n8n에서 직접 import할 수 있습니다.
+
+자세한 내용은 [워크플로우 템플릿 가이드](./WORKFLOW_TEMPLATES_README.md)를 참조하세요.
+
+## 🔧 개발
+
+```bash
+# 의존성 설치
+npm install
+
+# 빌드
+npm run build
+
+# 개발 모드 (watch)
+npm run dev
+
+# 린트
+npm run lint
+npm run lintfix
+```
+
+## 🔗 API 엔드포인트
+
+SeedOS API 엔드포인트:
+- `POST /write` - 메모리 블록 저장
+- `POST /search` - 의미 기반 검색
+- `POST /query` - AI 쿼리
+- `POST /identity` - Identity 생성
+- `POST /proof` - Merkle Proof 검증
+- `GET /read` - 메모리 블록 읽기
+- `GET /health` - Health check
+
+## 📖 추가 문서
+
+- [워크플로우 템플릿 가이드](./WORKFLOW_TEMPLATES_README.md)
+- [로컬 개발 가이드](./LOCAL_DEVELOPMENT.md)
+- [테스트 가이드](./LOCAL_TEST_GUIDE.md)
+- [npm 발행 가이드](./NPM_PUBLISH_GUIDE.md)
+
+## 🐛 문제 해결
+
+### "Invalid API key" 오류
+- SeedOS 서버가 실행 중인지 확인
+- API Key가 올바른지 확인
+- Credentials 설정 확인
+
+### "Identity not found" 오류
+- Identity가 생성되었는지 확인
+- 필요시 Identity 생성 워크플로우 실행
+
+### "Search failed" 오류
+- Identity가 생성되어 있는지 확인
+- 메모리가 저장되어 있는지 확인
+
+## 📝 라이선스
+
+MIT
+
+## 🔗 관련 링크
+
+- [SeedOS GitHub](https://github.com/seedos/seedos-mvp)
+- [SeedOS API 문서](https://github.com/seedos/seedos-mvp/blob/main/README.md)
+- [n8n 문서](https://docs.n8n.io/)

package/dist/credentials/SeedOSApi.credentials.d.ts

@@ -0,0 +1,25 @@
+import { ICredentialType, NodePropertyTypes } from 'n8n-workflow';
+export declare class SeedOSApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    documentationUrl: string;
+    properties: ({
+        displayName: string;
+        name: string;
+        type: NodePropertyTypes;
+        typeOptions: {
+            password: boolean;
+        };
+        default: string;
+        required: boolean;
+        description: string;
+    } | {
+        displayName: string;
+        name: string;
+        type: NodePropertyTypes;
+        default: string;
+        required: boolean;
+        description: string;
+        typeOptions?: undefined;
+    })[];
+}

package/dist/credentials/SeedOSApi.credentials.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeedOSApi = void 0;
+class SeedOSApi {
+    constructor() {
+        this.name = 'seedosApi';
+        this.displayName = 'SeedOS API';
+        this.documentationUrl = 'https://github.com/seedos/seedos-mvp';
+        this.properties = [
+            {
+                displayName: 'API Key',
+                name: 'apiKey',
+                type: 'string',
+                typeOptions: {
+                    password: true,
+                },
+                default: '',
+                required: true,
+                description: 'SeedOS API Key',
+            },
+            {
+                displayName: 'Base URL',
+                name: 'baseUrl',
+                type: 'string',
+                default: 'http://localhost:8000',
+                required: true,
+                description: 'SeedOS API Base URL',
+            },
+        ];
+    }
+}
+exports.SeedOSApi = SeedOSApi;

package/dist/nodes/SeedOS/GenericFunctions.d.ts

@@ -0,0 +1,2 @@
+import { IExecuteFunctions, IHttpRequestMethods } from 'n8n-workflow';
+export declare function seedosApiRequest(this: IExecuteFunctions, method: IHttpRequestMethods, endpoint: string, body?: any): Promise<any>;

package/dist/nodes/SeedOS/GenericFunctions.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seedosApiRequest = void 0;
+async function seedosApiRequest(method, endpoint, body) {
+    const credentials = await this.getCredentials('seedosApi');
+    const options = {
+        method: method,
+        url: `${credentials.baseUrl}${endpoint}`,
+        headers: {
+            'X-API-Key': credentials.apiKey,
+            'Content-Type': 'application/json',
+        },
+    };
+    if (body) {
+        options.body = JSON.stringify(body);
+    }
+    const response = await this.helpers.httpRequest(options);
+    return response;
+}
+exports.seedosApiRequest = seedosApiRequest;

package/dist/nodes/SeedOS/SeedOS.node.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class SeedOS implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/SeedOS/SeedOS.node.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeedOS = void 0;
+const GenericFunctions_1 = require("./GenericFunctions");
+class SeedOS {
+    constructor() {
+        this.description = {
+            displayName: 'SeedOS',
+            name: 'seedos',
+            icon: 'file:seedos.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: 'AI Memory System with Identity and Semantic Search',
+            defaults: {
+                name: 'SeedOS',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'seedosApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Store Memory',
+                            value: 'store',
+                            description: 'Store a memory block',
+                            action: 'Store a memory block',
+                        },
+                        {
+                            name: 'Search Memory',
+                            value: 'search',
+                            description: 'Search memories semantically',
+                            action: 'Search memories semantically',
+                        },
+                        {
+                            name: 'Query with AI',
+                            value: 'query',
+                            description: 'Query with Thalamic AI',
+                            action: 'Query with Thalamic AI',
+                        },
+                        {
+                            name: 'Create Identity',
+                            value: 'identity',
+                            description: 'Create AI identity',
+                            action: 'Create AI identity',
+                        },
+                        {
+                            name: 'Verify Proof',
+                            value: 'proof',
+                            description: 'Verify Merkle proof',
+                            action: 'Verify Merkle proof',
+                        },
+                    ],
+                    default: 'store',
+                },
+                // Store Memory fields
+                {
+                    displayName: 'Layer',
+                    name: 'layer',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['store'],
+                        },
+                    },
+                    default: 'memory',
+                    required: true,
+                    description: 'Memory layer (e.g., memory, identity)',
+                },
+                {
+                    displayName: 'Type',
+                    name: 'type',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['store'],
+                        },
+                    },
+                    default: 'event',
+                    required: true,
+                    description: 'Block type (e.g., event, judgment)',
+                },
+                {
+                    displayName: 'Payload',
+                    name: 'payload',
+                    type: 'json',
+                    displayOptions: {
+                        show: {
+                            operation: ['store'],
+                        },
+                    },
+                    default: '{}',
+                    required: true,
+                    description: 'Memory payload (JSON object)',
+                },
+                // Search Memory fields
+                {
+                    displayName: 'Query',
+                    name: 'query',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['search'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                    description: 'Search query text',
+                },
+                {
+                    displayName: 'Top K',
+                    name: 'topK',
+                    type: 'number',
+                    displayOptions: {
+                        show: {
+                            operation: ['search'],
+                        },
+                    },
+                    default: 5,
+                    description: 'Number of results to return',
+                },
+                // Query with AI fields
+                {
+                    displayName: 'Question',
+                    name: 'question',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['query'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                    description: 'Question to ask the AI',
+                },
+                {
+                    displayName: 'LLM Provider',
+                    name: 'llmProvider',
+                    type: 'options',
+                    displayOptions: {
+                        show: {
+                            operation: ['query'],
+                        },
+                    },
+                    options: [
+                        { name: 'OpenAI', value: 'openai' },
+                        { name: 'Anthropic', value: 'anthropic' },
+                    ],
+                    default: 'openai',
+                    description: 'LLM provider',
+                },
+                {
+                    displayName: 'Model',
+                    name: 'model',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['query'],
+                        },
+                    },
+                    default: 'gpt-4',
+                    description: 'Model name',
+                },
+                // Proof fields
+                {
+                    displayName: 'Address',
+                    name: 'address',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['proof'],
+                        },
+                    },
+                    default: '',
+                    required: true,
+                    description: 'Block address (MMP format)',
+                },
+                {
+                    displayName: 'Leaf Index',
+                    name: 'leafIndex',
+                    type: 'number',
+                    displayOptions: {
+                        show: {
+                            operation: ['proof'],
+                        },
+                    },
+                    default: 0,
+                    description: 'Leaf index in Merkle tree',
+                },
+                {
+                    displayName: 'Leaves',
+                    name: 'leaves',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['proof'],
+                        },
+                    },
+                    default: '[]',
+                    description: 'Merkle tree leaves (JSON array)',
+                },
+                {
+                    displayName: 'Leaf Value',
+                    name: 'leafValue',
+                    type: 'string',
+                    displayOptions: {
+                        show: {
+                            operation: ['proof'],
+                        },
+                    },
+                    default: '',
+                    description: 'Leaf value to verify',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const operation = this.getNodeParameter('operation', 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                let responseData;
+                switch (operation) {
+                    case 'store':
+                        responseData = await GenericFunctions_1.seedosApiRequest.call(this, 'POST', '/write', {
+                            layer: this.getNodeParameter('layer', i),
+                            type: this.getNodeParameter('type', i),
+                            payload: JSON.parse(this.getNodeParameter('payload', i)),
+                        });
+                        break;
+                    case 'search':
+                        responseData = await GenericFunctions_1.seedosApiRequest.call(this, 'POST', '/search', {
+                            query: this.getNodeParameter('query', i),
+                            top_k: this.getNodeParameter('topK', i),
+                        });
+                        break;
+                    case 'query':
+                        responseData = await GenericFunctions_1.seedosApiRequest.call(this, 'POST', '/query', {
+                            question: this.getNodeParameter('question', i),
+                            llm_provider: this.getNodeParameter('llmProvider', i),
+                            model: this.getNodeParameter('model', i),
+                        });
+                        break;
+                    case 'identity':
+                        const name = this.getNodeParameter('name', i);
+                        const purpose = this.getNodeParameter('purpose', i);
+                        const coreValuesStr = this.getNodeParameter('coreValues', i) || 'helpfulness, accuracy, privacy';
+                        const coreValues = coreValuesStr.split(',').map((v) => v.trim()).filter((v) => v.length > 0);
+                        const role = this.getNodeParameter('role', i) || 'SeedOS';
+                        responseData = await GenericFunctions_1.seedosApiRequest.call(this, 'POST', '/identity', {
+                            name,
+                            purpose,
+                            core_values: coreValues.length > 0 ? coreValues : ['helpfulness', 'accuracy', 'privacy'],
+                            role,
+                        });
+                        break;
+                    case 'proof':
+                        responseData = await GenericFunctions_1.seedosApiRequest.call(this, 'POST', '/proof', {
+                            address: this.getNodeParameter('address', i),
+                            leaf_index: this.getNodeParameter('leafIndex', i),
+                            leaves: JSON.parse(this.getNodeParameter('leaves', i)),
+                            leaf_value: this.getNodeParameter('leafValue', i),
+                        });
+                        break;
+                    default:
+                        throw new Error(`Unknown operation: ${operation}`);
+                }
+                returnData.push({
+                    json: responseData,
+                    pairedItem: {
+                        item: i,
+                    },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    returnData.push({
+                        json: { error: errorMessage },
+                        pairedItem: {
+                            item: i,
+                        },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.SeedOS = SeedOS;

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@youngkang/n8n-nodes-seedos",
+  "version": "0.1.0",
+  "description": "SeedOS Memory System integration for n8n",
+  "keywords": [
+    "n8n-community-node-package",
+    "seedos",
+    "memory",
+    "ai",
+    "semantic-search"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/seedos/seedos-mvp",
+  "author": {
+    "name": "SeedOS Team"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/seedos/seedos-mvp.git",
+    "directory": "integrations/n8n"
+  },
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc && gulp build:icons",
+    "dev": "tsc --watch",
+    "format": "prettier nodes credentials --write",
+    "lint": "eslint \"nodes/**/*.ts\" \"credentials/**/*.ts\" package.json || true",
+    "lintfix": "eslint \"nodes/**/*.ts\" \"credentials/**/*.ts\" package.json --fix || true",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "nodes": [
+      "dist/nodes/SeedOS/SeedOS.node.js"
+    ],
+    "credentials": [
+      "dist/credentials/SeedOSApi.credentials.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^18.15.0",
+    "@typescript-eslint/parser": "^5.57.0",
+    "eslint-plugin-n8n-nodes-base": "^1.11.0",
+    "gulp": "^4.0.2",
+    "n8n-workflow": "*",
+    "prettier": "^2.8.8",
+    "typescript": "~5.1.6"
+  },
+  "dependencies": {
+    "n8n-workflow": "*"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "*"
+  }
+}