mkdir simple-agent
cd simple-agent
npm init -y # package.json 생성
npm install typescript ts-node @types/node --save-dev # 타입스크립트 설치
npx tsc --init # tsconfig.json 생성
npm install openai dotenv # 라이브러리 설치

// src/chatAgent.ts
import OpenAI from 'openai';
import readline from 'readline';

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

export async function startChatAgent() {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });

  console.log('💬 AI 에이전트와의 대화를 시작합니다. 종료하려면 Ctrl+C를 누르세요.\n');

  while (true) {
    const userInput = await new Promise<string>((resolve) => {
      rl.question('👤 사용자: ', resolve);
    });

    const res = await openai.chat.completions.create({
      model: 'gpt-4-0613',
      messages: [{ role: 'user', content: userInput }],
    });

    const reply = res.choices[0].message?.content;
    console.log(`🤖 에이전트: ${reply}\n`);
  }
}

// src/index.ts
import dotenv from 'dotenv';
dotenv.config();

import { startChatAgent } from './chatAgent';

startChatAgent();

# .env
OPENAI_API_KEY=... # OpenAI API 키

npx ts-node src/index.ts
💬 AI 에이전트와의 대화를 시작합니다. 종료하려면 Ctrl+C를 누르세요.

👤 사용자: 안녕하세요. 잘 지내시나요?
🤖 에이전트: 안녕하세요! 저는 잘 지내고 있습니다. 당신은 어떻게 지내시나요? 도움이 필요하시면 언제든지 말씀해 주세요!

👤 사용자: 

npm install rss-parser

// src/tools.ts
import Parser from 'rss-parser';

const parser = new Parser();

export async function fetchGeekNewsFeed(): Promise<string[]> {
  const feed = await parser.parseURL('https://feeds.feedburner.com/geeknews-feed');
  return feed.items.slice(0, 20).map(item => `${item.title}\n${item.link}`);
}

// src/toolSchema.ts
import { ChatCompletionTool } from "openai/resources/chat";

export const tools: ChatCompletionTool[] = [
  {
    type: "function",
    function: {
      name: "fetchGeekNewsFeed",
      description: "긱뉴스에서 최근 뉴스 항목을 가져옵니다",
      parameters: {
        type: "object",
        properties: {},
        required: [],
      },
    },
  },
];

import OpenAI from "openai";
import readline from "readline";
import { tools } from "./toolSchema";
import { fetchGeekNewsFeed } from "./tools";

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

export async function startChatAgent() {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });

  console.log(
    "💬 AI 에이전트와의 대화를 시작합니다. 종료하려면 Ctrl+C를 누르세요.\n"
  );

  while (true) {
    const userInput = await new Promise<string>((resolve) => {
      rl.question("👤 사용자: ", resolve);
    });

    const res = await openai.chat.completions.create({
      model: "gpt-4o-mini",
      messages: [{ role: "user", content: userInput }],
      tools,
      tool_choice: "auto",
    });

    const choice = res.choices[0];
    const msg = choice.message;

    if (msg.tool_calls?.[0]?.function.name === "fetchGeekNewsFeed") {
      const data = await fetchGeekNewsFeed();
      console.log("📡 긱뉴스 결과:\n", data.join("\n\n"));
    } else {
      console.log(`🤖 에이전트: ${msg.content ?? "(응답 없음)"}`);
    }
  }
}

 npx ts-node src/index.ts
💬 AI 에이전트와의 대화를 시작합니다. 종료하려면 Ctrl+C를 누르세요.

👤 사용자: 안녕하세요
🤖 에이전트: 안녕하세요! 무엇을 도와드릴까요?
👤 사용자: 최근 긱뉴스 글 알려주세요
📡 긱뉴스 결과:
Ask GN: LLM으로 생산성이 증가한거 같은데요. 왜 저는 여전히 바쁠까요?
https://news.hada.io/topic?id=20632

샤오미 MiMo 추론 모델
https://news.hada.io/topic?id=20631

AI 이미지 생성 서비스 Civit이 검열을 강화하는 진짜 이유 - "Visa"
https://news.hada.io/topic?id=20630

...

[
  { "action": "fetchGeekNewsFeed" },
  { "action": "filter", "args": { "keyword": "AI" } },
  { "action": "summarize" },
  { "action": "sendEmail", "args": { "subject": "오늘의 뉴스" } }
]

// src/plannerAgent.ts
import OpenAI from "openai";
import { tools } from "./toolSchema";

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

function getToolDescriptions(): string {
  return tools
    .map((t) => {
      const name = t.function.name;
      const desc = t.function.description;
      return `- ${name}: ${desc}`;
    })
    .join("\n");
}

export async function createStructuredPlan(
  userRequest: string
): Promise<any[]> {
  const prompt = `
당신은 사용자의 자연어 요청을 계획으로 분해하는 시스템입니다.

다음은 사용할 수 있는 도구 목록입니다:
${getToolDescriptions()}

**주의:**
- 요청에 명시된 작업만 계획하세요.
- 추론을 통해 추가 도구를 사용하지 마세요.
- 코드 블록을 사용하지 마세요.
- 각 작업은 JSON 객체로 표현되어야 하며, "action" 필드와 선택적 "args" 필드를 포함해야 합니다.

요청: "${userRequest}"

출력 예시:
[
  { "action": "fetchGeekNewsFeed" },
  { "action": "filter", "args": { "keyword": "AI" } },
  { "action": "sendEmail", "args": { "subject": "오늘의 뉴스" } }
]
`;

  const res = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [{ role: "user", content: prompt }],
  });

  const planText = res.choices[0].message?.content ?? "[]";
  const clean = planText
    .replace(/^```json/, "")
    .replace(/^```/, "")
    .replace(/```$/, "")
    .trim();
  return JSON.parse(clean);
}

import * as tools from "./tools";

type PlanStep = {
  action: string;
  args?: Record<string, any>;
};

export async function executeStructuredPlan(plan: PlanStep[]) {
  let context = ""; // 초기 context는 빈 문자열

  for (let i = 0; i < plan.length; i++) {
    const { action, args } = plan[i];
    const tool = (tools as any)[action];

    if (!tool) {
      console.warn(`⚠️ 등록되지 않은 도구: ${action}`);
      continue;
    }

    console.log(`\n🚀 [${i}] 실행: ${action}`);
    if (args) console.log(`🔧 args: ${JSON.stringify(args)}`);

    try {
      context = await tool(context, args);
    } catch (err) {
      console.error(`❌ ${action} 실행 중 오류 발생`, err);
    }
  }

  console.log("\n✅ 최종 결과:");
  console.log(context);
}

npm install nodemailer
npm install @types/nodemailer --save-dev # 타입 정의 설치

import Parser from "rss-parser";
import nodemailer from "nodemailer";
import OpenAI from "openai";

const parser = new Parser();
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

export async function fetchGeekNewsFeed(): Promise<string> {
  const feed = await parser.parseURL(
    "https://feeds.feedburner.com/geeknews-feed"
  );
  return feed.items
    .slice(0, 20)
    .map((item, index) => `${index + 1}. ${item.title} / ${item.link}`)
    .join("\n\n");
}

export async function filter(
  context: string,
  args: { keyword: string }
): Promise<string> {
  const prompt = `다음 항목들 중 '${args.keyword}'와 관련된 항목만 골라주세요.`;

  const res = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [{ role: "user", content: `${prompt}\n\n${context}` }],
  });

  const text = res.choices[0].message?.content ?? "";
  return text;
}

export async function sendEmail(
  context: string,
  args: { subject: string }
): Promise<string> {
  const transporter = nodemailer.createTransport({
    service: "gmail",
    auth: {
      user: process.env.EMAIL_FROM,
      pass: process.env.EMAIL_PASS,
    },
  });

  await transporter.sendMail({
    from: process.env.EMAIL_FROM,
    to: process.env.EMAIL_TO,
    subject: args.subject,
    text: context,
  });

  console.log("📧 이메일 전송 완료");
  return "이메일 전송 완료";
}

export async function print(
  context: string,
  args: { subject: string }
): Promise<string> {
  console.log("📜 출력:", context);
  return "출력 완료";
}

// src/toolSchema.ts
import { ChatCompletionTool } from "openai/resources/chat";

export const tools: ChatCompletionTool[] = [
  {
    type: "function",
    function: {
      name: "fetchGeekNewsFeed",
      description: "긱뉴스에서 최근 뉴스 항목을 가져옵니다",
      parameters: {
        type: "object",
        properties: {},
        required: [],
      },
    },
  },
  {
    type: "function",
    function: {
      name: "filter",
      description: "문자열 항목을 키워드와 관련 있는 것으로 필터링합니다",
      parameters: {
        type: "object",
        properties: {
          keyword: {
            type: "string",
            description: "필터링할 키워드",
          },
        },
        required: ["keyword"],
      },
    },
  },
  {
    type: "function",
    function: {
      name: "sendEmail",
      description: "이메일을 보냅니다",
      parameters: {
        type: "object",
        properties: {
          subject: {
            type: "string",
            description: "이메일 제목",
          },
          body: {
            type: "string",
            description: "이메일 본문",
          },
        },
        required: ["subject", "body"],
      },
    },
  },
];

import readline from "readline";
import { createStructuredPlan } from "./plannerAgent";
import { executeStructuredPlan } from "./executor";

export async function startChatAgent() {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });

  console.log(
    "💬 AI 에이전트와의 대화를 시작합니다. 종료하려면 Ctrl+C를 누르세요.\n"
  );

  while (true) {
    const userInput = await new Promise<string>((resolve) => {
      rl.question("👤 사용자: ", resolve);
    });

    try {
      const plan = await createStructuredPlan(userInput);

      const isValidPlan =
        Array.isArray(plan) && plan.every((p) => typeof p.action === "string");
      if (isValidPlan) {
        console.log("🗺 계획:", plan);
        await executeStructuredPlan(plan);
      }
    } catch (e) {
      console.error("⚠️ 계획 생성 중 오류 발생:", e);
    }
  }
}

npx ts-node src/index.ts
💬 AI 에이전트와의 대화를 시작합니다. 종료하려면 Ctrl+C를 누르세요.

👤 사용자: 긱뉴스에서 최근 글을 가져와서 인공지능(AI) 관련 글만 필터링하고 이메일로 보내줘
🗺 계획: [
  { action: 'fetchGeekNewsFeed' },
  { action: 'filter', args: { keyword: 'AI' } },
  { action: 'sendEmail', args: { subject: '오늘의 AI 관련 뉴스' } }
]
🚀 실행 중: fetchGeekNewsFeed
🚀 실행 중: filter
🚀 실행 중: sendEmail
📧 이메일 전송 완료

// src/memory.ts
type MemoryStore = {
  [step: string]: any;
};

const memory: MemoryStore = {};

// src/executor.ts
import * as tools from "./tools";
import { memory } from "./memory";

type PlanStep = {
  action: string;
  args?: Record<string, any>;
  saveAs?: string;
  inputFrom?: string;
};

export async function executeStructuredPlan(plan: PlanStep[]) {
  let context = "";

  for (let i = 0; i < plan.length; i++) {
    const { action, args = {}, saveAs, inputFrom } = plan[i];
    const tool = (tools as any)[action];

    if (!tool) {
      console.warn(`⚠️ 등록되지 않은 도구: ${action}`);
      continue;
    }

    const input = inputFrom ? memory[inputFrom] ?? "" : context;

    // args 내의 메모리 참조 해석
    const resolvedArgs: Record<string, any> = {};
    for (const [k, v] of Object.entries(args)) {
      if (typeof v === "string" && memory[v]) {
        resolvedArgs[k] = memory[v];
      } else {
        resolvedArgs[k] = v;
      }
    }

    console.log(`\n🚀 [${i}] 실행: ${action}`);
    if (inputFrom) console.log(`↪️ inputFrom: '${inputFrom}'`);
    if (saveAs) console.log(`💾 saveAs: '${saveAs}'`);
    if (Object.keys(args).length > 0) {
      console.log(`🔧 args: ${JSON.stringify(resolvedArgs)}`);
    }

    try {
      const result = await tool(input, resolvedArgs);
      context = result;
      if (saveAs) {
        memory[saveAs] = result;
      }
    } catch (err) {
      console.error(`❌ ${action} 실행 중 오류 발생`, err);
    }
  }

  console.log("\n🧠 메모리 상태:");
  for (const [key, value] of Object.entries(memory)) {
    const lines = value.split("\n").length;
    const preview = value.slice(0, 100).replace(/\n/g, " ");
    console.log(
      `- ${key} (${lines}줄): ${preview}${value.length > 100 ? "..." : ""}`
    );
  }
}

// src/plannerAgent.ts
import OpenAI from "openai";
import { tools } from "./toolSchema";
import { memory } from "./memory";
import { ChatCompletionMessageParam } from "openai/resources/chat";

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

function getToolDescriptions(): string {
  return tools
    .map((t) => {
      const name = t.function.name;
      const desc = t.function.description;
      return `- ${name}: ${desc}`;
    })
    .join("\n");
}

function getMemoryDescription(): string {
  const keys = Object.keys(memory);
  if (keys.length === 0) return "현재 저장된 메모리는 없습니다.";

  return `현재 사용 가능한 메모리 키: ${keys
    .map((k) => `"${k}"`)
    .join(", ")}\n\ninputFrom 또는 args에서 사용할 수 있습니다.`;
}

export async function createStructuredPlan(
  userRequest: string
): Promise<any[]> {
  const messages: ChatCompletionMessageParam[] = [
    {
      role: "system",
      content: `
당신은 사용자의 자연어 요청을 계획으로 분해하는 시스템입니다.

다음은 사용할 수 있는 도구 목록입니다:
${getToolDescriptions()}

다음은 현재까지의 메모리 상태입니다:
${getMemoryDescription()}

**주의:**
- 요청에 명시된 작업만 계획하세요.
- 추론을 통해 추가 도구를 사용하지 마세요.
- 코드 블록을 사용하지 마세요.
- 각 작업은 JSON 객체로 표현되어야 하며, "action" 필드와 선택적 "args", "saveAs", "inputFrom" 필드를 포함해야 합니다.
- 도구 결과를 재사용하려면 'saveAs'로 저장하고, 'inputFrom'으로 참조하세요.

출력 예시:
[
  { "action": "fetchGeekNewsFeed", "args": {}, "saveAs": "news" },
  { "action": "filter", "args": { "keyword": "AI" }, "inputFrom": "news", "saveAs": "filteredNews" },
  { "action": "sendEmail", "args": { "subject": "AI 관련 뉴스" }, "inputFrom": "filteredNews" }
]
`,
    },
    {
      role: "user",
      content: userRequest,
    },
  ];

  const res = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    messages,
  });

  const planText = res.choices[0].message?.content ?? "[]";
  const clean = planText
    .replace(/^```json/, "")
    .replace(/^```/, "")
    .replace(/```$/, "")
    .trim();
  return JSON.parse(clean);
}

npx ts-node src/index.ts
💬 AI 에이전트와의 대화를 시작합니다. 종료하려면 Ctrl+C를 누르세요.

👤 사용자: 긱뉴스에서 AI 관련 뉴스는 이메일로, 프론트엔드 관련 뉴스는 콘솔에 출력해줘
🗺 계획: [
  { action: 'fetchGeekNewsFeed', args: {}, saveAs: 'news' },
  {
    action: 'filter',
    args: { keyword: 'AI' },
    inputFrom: 'news',
    saveAs: 'aiNews'
  },
  {
    action: 'filter',
    args: { keyword: '프론트엔드' },
    inputFrom: 'news',
    saveAs: 'frontendNews'
  },
  {
    action: 'sendEmail',
    args: { subject: 'AI 관련 뉴스' },
    inputFrom: 'aiNews'
  },
  {
    action: 'print',
    args: { message: '프론트엔드 관련 뉴스: ' },
    inputFrom: 'frontendNews'
  }
]

🚀 [0] 실행: fetchGeekNewsFeed
💾 saveAs: 'news'

🚀 [1] 실행: filter
↪️ inputFrom: 'news'
💾 saveAs: 'aiNews'
🔧 args: {"keyword":"AI"}

🚀 [2] 실행: filter
↪️ inputFrom: 'news'
💾 saveAs: 'frontendNews'
🔧 args: {"keyword":"프론트엔드"}

🚀 [3] 실행: sendEmail
↪️ inputFrom: 'aiNews'
🔧 args: {"subject":"AI 관련 뉴스"}
📧 이메일 전송 완료

🚀 [4] 실행: print
↪️ inputFrom: 'frontendNews'
🔧 args: {"message":"프론트엔드 관련 뉴스: "}
📜 출력: '프론트엔드'와 관련된 항목은 다음과 같습니다:

10. 왜 우리는 RGB와 HSL에서 OKLCH로 전환했을까요? (번역) / https://news.hada.io/topic?id=20623

이 항목은 색상 모델에 대한 내용으로, 프론트엔드 개발에서 스타일링과 UI 디자인에 관련된 중요한 요소입니다. 나머지 항목들은 주로 경제, AI, 비즈니스 관련 내용으로 보입니다.

🧠 메모리 상태:
- news (19줄): 1. Ask GN: LLM으로 생산성이 증가한거 같은데요. 왜 저는 여전히 바쁠까요? / https://news.hada.io/topic?id=20632  2. 샤오미 MiMo 추...
- aiNews (11줄): 'AI'와 관련된 항목은 다음과 같습니다.  1. Ask GN: LLM으로 생산성이 증가한거 같은데요. 왜 저는 여전히 바쁠까요? / https://news.hada.io/topi...
- frontendNews (5줄): '프론트엔드'와 관련된 항목은 다음과 같습니다:  10. 왜 우리는 RGB와 HSL에서 OKLCH로 전환했을까요? (번역) / https://news.hada.io/topic?id...
👤 사용자: 아까 봤던 프론트엔드 뉴스도 이메일로 보내줘
🗺 계획: [
  {
    action: 'sendEmail',
    args: { subject: '프론트엔드 뉴스' },
    inputFrom: 'frontendNews'
  }
]

🚀 [0] 실행: sendEmail
↪️ inputFrom: 'frontendNews'
🔧 args: {"subject":"프론트엔드 뉴스"}
📧 이메일 전송 완료

🧠 메모리 상태:
- news (19줄): 1. Ask GN: LLM으로 생산성이 증가한거 같은데요. 왜 저는 여전히 바쁠까요? / https://news.hada.io/topic?id=20632  2. 샤오미 MiMo 추...
- aiNews (11줄): 'AI'와 관련된 항목은 다음과 같습니다.  1. Ask GN: LLM으로 생산성이 증가한거 같은데요. 왜 저는 여전히 바쁠까요? / https://news.hada.io/topi...
- frontendNews (5줄): '프론트엔드'와 관련된 항목은 다음과 같습니다:  10. 왜 우리는 RGB와 HSL에서 OKLCH로 전환했을까요? (번역) / https://news.hada.io/topic?id...
👤 사용자: