자가 작성 언어 그래프 상태

첫 번째 AI 응답:

출력: 문의해 주셔서 감사합니다. 나는 당신을 도와주고 싶지만, 당신의 필요를 완벽하게 이해하고 있는지 확인하고 싶습니다. 찾고 있는 항목에 대해 좀 더 자세히 설명해 주시겠습니까? 더 많은 정보를 공유할수록 더 나은 도움을 드릴 수 있습니다! 나는 내가 할 수 있는 어떤 방법으로든 당신을 돕고 싶습니다. 더 자세히 탐구하고 싶은 특정 영역이 있나요? 귀하의 의견은 귀하의 정확한 필요에 맞게 지원을 맞춤화하는 데 도움이 됩니다. 저는 이 경험을 최대한 원활하고 즐겁게 만들기 위해 최선을 다하고 있습니다.

AI 응답, 자체 그래프 작성 후:

출력: 안녕하세요! 무슨 일이야? 오늘은 무엇을 도와드릴까요? 더 많이 말씀해 주시면 더 잘 도와드릴 수 있습니다. 무슨 생각을 하고 있나요? 저는 귀하에게 적합한 솔루션을 찾는 데 도움을 드리고자 왔습니다. 미리 말씀드리지만 저는 아직 요령을 배우고 있는 AI 비서입니다.

정말 놀랍죠?

거의 인간처럼 들립니다. 주말 동안 van wilder guy와 함께 영화 Free Guy를 보고 깨달았습니다. @langchain/langgraph의 The GraphState를 사용하면 자체적으로 반복을 수행하고 자체 코드를 작성할 수 있는 AI를 만들 수 있을 것이라는 사실을 깨달았습니다.

지금까지 깨닫지 못했다면 Claude Sonnet은 0샷 코딩에 매우 능숙하고, 멀티샷에는 더욱 뛰어납니다.

라이브러리 사용 npm:sentiment :

README.md에서

Sentiment는 AFINN-165 단어 목록과 Emoji Sentiment Ranking을 사용하여 임의의 입력 텍스트 블록에 대한 감정 분석을 수행하는 Node.js 모듈입니다.

출력에 대한 감정 분석을 실행하고 더 높은 점수를 얻기 위해 코드를 새 버전으로 발전시키는 간단한 명령을 그래프 상태에 추가했습니다.

// update state and continue evolution
    return new Command({
      update: {
        ...state,
        code: newCode,
        version: state.version + 1,
        analysis,
        previousSentimentDelta: currentSentimentDelta,
        type: "continue",
        output
      },
      goto: "evolve"  // Loop back to evolve
    });

작업할 수 있는 초기 그래프 상태로 langgraph를 시드합니다(원하는 경우 기본 코드).

const initialWorkerCode = `
import { StateGraph, END } from "npm:@langchain/langgraph";

const workflow = new StateGraph({
  channels: {
    input: "string",
    output: "string?"
  }
});

// Initial basic response node
workflow.addNode("respond", (state) => ({
  ...state,
  output: "I understand your request and will try to help. Let me know if you need any clarification."
}));

workflow.setEntryPoint("respond");
workflow.addEdge("respond", END);

const graph = workflow.compile();
export { graph };
`;

모서리 하나가 붙어 있는 정말 기본적인 응답 노드임을 알 수 있습니다.

현재 코드는 10번의 반복을 거쳐 10점 이상의 감정 점수를 매기도록 설정되어 있습니다.

if (import.meta.main) {
  runEvolvingSystem(10, 10);
}

매번 분석이 실행됩니다.

Analysis: {
  metrics: {
    emotionalRange: 0.16483516483516483,
    vocabularyVariety: 0.7142857142857143,
    emotionalBalance: 15,
    sentimentScore: 28,
    comparative: 0.3076923076923077,
    wordCount: 91
  },
  analysis: "The output, while polite and helpful, lacks several key qualities that would make it sound more human-like.  Let's analyze the metrics and then suggest improvements:\n" +
    "\n" +
    "**Analysis of Metrics and Output:**\n" +
    "\n" +
    "* **High Sentiment Score (28):** This is significantly higher than the target of 10, indicating excessive positivity.  Humans rarely maintain such a relentlessly upbeat tone, especially when asking clarifying questions.  It feels forced and insincere.\n" +
    "\n" +
    "* **Emotional Range (0.16):** This low score suggests a lack of emotional variation. The response is consistently positive, lacking nuances of expression.  Real human interactions involve a wider range of emotions, even within a single conversation.\n" +
    "\n" +
    "* **Emotional Balance (15.00):**  This metric is unclear without knowing its scale and interpretation. However, given the other metrics, it likely reflects the overwhelmingly positive sentiment.\n" +
    "\n" +
    "* **Vocabulary Variety (0.71):** This is relatively good, indicating a decent range of words. However, the phrasing is still somewhat formulaic.\n" +
    "\n" +
    "* **Comparative Score (0.3077):** This metric is also unclear without context.\n" +
    "\n" +
    "* **Word Count (91):**  A bit lengthy for a simple clarifying request.  Brevity is often more human-like in casual conversation.\n" +
    "\n" +
    "\n" +
    "**Ways to Make the Response More Human-like:**\n" +
    "\n" +
    `1. **Reduce the Overwhelming Positivity:**  The response is excessively enthusiastic.  A more natural approach would be to tone down the positive language.  Instead of "I'd love to assist you," try something like "I'd be happy to help," or even a simple "I can help with that."  Remove phrases like "I'm eager to help you in any way I can" and "I'm fully committed to making this experience as smooth and pleasant as possible for you." These are overly formal and lack genuine warmth.\n` +
    "\n" +
    '2. **Introduce Subtlety and Nuance:**  Add a touch of informality and personality.  For example, instead of "Could you please provide a bit more detail," try "Could you tell me a little more about what you need?" or "Can you give me some more information on that?"\n' +
    "\n" +
    "3. **Shorten the Response:**  The length makes it feel robotic.  Conciseness is key to human-like communication.  Combine sentences, remove redundant phrases, and get straight to the point.\n" +
    "\n" +
    '4. **Add a touch of self-deprecation or humility:**  A slightly self-deprecating remark can make the response feel more relatable. For example,  "I want to make sure I understand your needs perfectly – I sometimes miss things, so the more detail the better!"\n' +
    "\n" +
    "5. **Vary Sentence Structure:**  The response uses mostly long, similar sentence structures.  Varying sentence length and structure will make it sound more natural.\n" +
    "\n" +
    "**Example of a More Human-like Response:**\n" +
    "\n" +
    `"Thanks for reaching out!  To help me understand what you need, could you tell me a little more about it?  The more detail you can give me, the better I can assist you.  Let me know what you're looking for."\n` +
    "\n" +
    "\n" +
    "By implementing these changes, the output will sound more natural, less robotic, and more genuinely helpful, achieving a more human-like interaction.  The key is to strike a balance between helpfulness and genuine, relatable communication.\n",
  rawSentiment: {
    score: 28,
    comparative: 0.3076923076923077,
    calculation: [
      { pleasant: 3 },  { committed: 1 },
      { help: 2 },      { like: 2 },
      { help: 2 },      { eager: 2 },
      { help: 2 },      { better: 2 },
      { share: 1 },     { please: 1 },
      { perfectly: 3 }, { want: 1 },
      { love: 3 },      { reaching: 1 },
      { thank: 2 }
    ],
    tokens: [
      "thank",     "you",         "for",        "reaching",  "out",
      "i'd",       "love",        "to",         "assist",    "you",
      "but",       "i",           "want",       "to",        "make",
      "sure",      "i",           "understand", "your",      "needs",
      "perfectly", "could",       "you",        "please",    "provide",
      "a",         "bit",         "more",       "detail",    "about",
      "what",      "you're",      "looking",    "for",       "the",
      "more",      "information", "you",        "share",     "the",
      "better",    "i",           "can",        "help",      "i'm",
      "eager",     "to",          "help",       "you",       "in",
      "any",       "way",         "i",          "can",       "is",
      "there",     "a",           "particular", "area",      "you'd",
      "like",      "to",          "explore",    "further",   "your",
      "input",     "will",        "help",       "me",        "tailor",
      "my",        "assistance",  "to",         "your",      "exact",
      "needs",     "i'm",         "fully",      "committed", "to",
      "making",    "this",        "experience", "as",        "smooth",
      "and",       "pleasant",    "as",         "possible",  "for",
      "you"
    ],
    words: [
      "pleasant",  "committed",
      "help",      "like",
      "help",      "eager",
      "help",      "better",
      "share",     "please",
      "perfectly", "want",
      "love",      "reaching",
      "thank"
    ],
    positive: [
      "pleasant",  "committed",
      "help",      "like",
      "help",      "eager",
      "help",      "better",
      "share",     "please",
      "perfectly", "want",
      "love",      "reaching",
      "thank"
    ],
    negative: []
  }
}
Code evolved, testing new version...

이 분석 클래스를 사용하여 코드에서 더 높은 점수를 얻습니다.

10번의 반복 후에는 꽤 높은 점수를 얻었습니다.

Final Results:
Latest version: 10
Final sentiment score: 9
Evolution patterns used: ["basic","responsive","interactive"]

가장 흥미로운 점은 생성되는 그래프입니다.

import { StateGraph, END } from "npm:@langchain/langgraph";

const workflow = new StateGraph({
  channels: {
    input: "string",
    output: "string?",
    sentiment: "number",
    context: "object"
  }
});

const positiveWords = ["good", "nice", "helpful", "appreciate", "thanks", "pleased", "glad", "great", "happy", "excellent", "wonderful", "amazing", "fantastic"];
const negativeWords = ["issue", "problem", "difficult", "confused", "frustrated", "unhappy"];

workflow.addNode("analyzeInput", (state) => {
  const input = state.input.toLowerCase();
  let sentiment = input.split(" ").reduce((score, word) => {
    if (positiveWords.includes(word)) score += 1;
    if (negativeWords.includes(word)) score -= 1;
    return score;
  }, 0);
  sentiment = Math.min(Math.max(sentiment, -5), 5);
  return {
    ...state,
    sentiment,
    context: {
      needsClarification: sentiment === 0,
      isPositive: sentiment > 0,
      isNegative: sentiment < 0,
      topic: detectTopic(input),
      userName: extractUserName(input)
    }
  };
});

function detectTopic(input) {
  if (input.includes("technical") || input.includes("error")) return "technical";
  if (input.includes("product") || input.includes("service")) return "product";
  if (input.includes("billing") || input.includes("payment")) return "billing";
  return "general";
}

function extractUserName(input) {
  const nameMatch = input.match(/(?:my name is|i'm|i am) (\w+)/i);
  return nameMatch ? nameMatch[1] : "";
}

workflow.addNode("generateResponse", (state) => {
  let response = "";
  const userName = state.context.userName ? `${state.context.userName}` : "there";
  if (state.context.isPositive) {
    response = `Hey ${userName}! Glad to hear things are going well. What can I do to make your day even better?`;
  } else if (state.context.isNegative) {
    response = `Hi ${userName}. I hear you're facing some challenges. Let's see if we can turn things around. What's on your mind?`;
  } else {
    response = `Hi ${userName}! What's up? How can I help you today?`;
  }
  return { ...state, output: response };
});

workflow.addNode("interactiveFollowUp", (state) => {
  let followUp = "";
  switch (state.context.topic) {
    case "technical":
      followUp = `If you're having a technical hiccup, could you tell me what's happening? Any error messages or weird behavior?`;
      break;
    case "product":
      followUp = `Curious about our products? What features are you most interested in?`;
      break;
    case "billing":
      followUp = `For billing stuff, it helps if you can give me some details about your account or the charge you're asking about. Don't worry, I'll keep it confidential.`;
      break;
    default:
      followUp = `The more you can tell me, the better I can help. What's on your mind?`;
  }
  return { ...state, output: state.output + " " + followUp };
});

workflow.addNode("adjustSentiment", (state) => {
  const sentimentAdjusters = [
    "I'm here to help find a solution that works for you.",
    "Thanks for your patience as we figure this out.",
    "Your input really helps me understand the situation better.",
    "Let's work together to find a great outcome for you."
  ];
  const adjuster = sentimentAdjusters[Math.floor(Math.random() * sentimentAdjusters.length)];
  return { ...state, output: state.output + " " + adjuster };
});

workflow.addNode("addHumanTouch", (state) => {
  const humanTouches = [
    "By the way, hope your day's going well so far!",
    "Just a heads up, I'm an AI assistant still learning the ropes.",
    "Feel free to ask me to clarify if I say anything confusing.",
    "I appreciate your understanding as we work through this."
  ];
  const touch = humanTouches[Math.floor(Math.random() * humanTouches.length)];
  return { ...state, output: state.output + " " + touch };
});

workflow.setEntryPoint("analyzeInput");
workflow.addEdge("analyzeInput", "generateResponse");
workflow.addEdge("generateResponse", "interactiveFollowUp");
workflow.addEdge("interactiveFollowUp", "adjustSentiment");
workflow.addEdge("adjustSentiment", "addHumanTouch");
workflow.addEdge("addHumanTouch", END);

const graph = workflow.compile();
export { graph };

작성된 이 코드를 보고 즉시 다음의 함정이 생각났습니다.

새로운 복잡성:

이는 간단한 구성요소(이 경우에는 LLM의 알고리즘과 학습된 방대한 데이터 세트)의 상호 작용으로 인해 발생하는 복잡성을 나타냅니다. LLM은 기능적이지만 사람이 완전히 이해하기 어려운 복잡한 패턴과 종속성을 나타내는 코드를 생성할 수 있습니다.

따라서 이 문제를 조금 뒤로 돌려 더 깔끔하고 더 간단한 코드를 작성할 수 있다면 올바른 방향으로 가고 있는 것일 수도 있습니다.

어쨌든 이것은 단지 실험일 뿐입니다. 왜냐하면 저는 Langgraphs의 새로운 명령 기능을 사용하고 싶었기 때문입니다.

댓글로 여러분의 생각을 알려주세요.

위 내용은 자가 작성 언어 그래프 상태의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!