영리의 테크블로그

해커톤 준비 / Human In The Loop(HITL) 란?

영리0 — Sun, 29 Jun 2025 21:17:29 +0900

이번 해커톤에서 백엔드/AI 파트를 맡아 쉬운말 번역기 라는 서비스의 흐름을 설계해보았다.

이 글은 langgraph 로 '문서 분기 - ocr - 쉬운말 변환 - tts' 를 어떻게 한 파이프라인으로 묶었는지 정리한 글이다.

백엔드 파이프라인

auth/ratelimit : fastapi 로 구현 / 파일 업로드, jwt 인증, websocket 브릿지
worker : 분기, 재시도, 스트림 처리
s3 : 이미지,음성 저장
db : 작업 메타데이터, 사용자 로그 저장

그래프 구조 짜기

세부 노드 설명

load doc : S3 등 이미지 서버에서 발급
ocr snippit : OCR
classfiy doc : OCR 내용 공적/사적 판별
private : 로그인 리턴
public : 다음 노드로 이동
easy translate : LLM 스트림 호출 -> 토큰 스트림 yeild -> websocket 전송
error : 서버 오류일시 재시도 클라이언트 오류일시 휴먼인더루프 실행
tts : 비동기로? 미정임
return : 최종상태 push

Human In The Loop (휴먼인더루프)

Human In The Loop (HITL) 란 자동화된 LLM 워크플로우 중간에 사람을 끼워 넣어 오류리스크를 최소화하는 장치이다.

LangGraph 에서는 이를 위해 그래프 진행을 일시 중단하고 사람 입력을 받아 재시동할 수 있는 기능을 제공한다.

LangGraph 가 제공하는 HITL 메커니즘

https://langchain-ai.github.io/langgraph/concepts/human_in_the_loop/

Overview

hil human-in-the-loop overview Human-in-the-loop To review, edit, and approve tool calls in an agent or workflow, use LangGraph's human-in-the-loop features to enable human intervention at any point in a workflow. This is especially useful in large languag

langchain-ai.github.io

기능	설명	코드
그래프 중단	노드에서 interrupt() 호출 → RUNNING → INTERRUPTED 상태	return interrupt(data=my_payload)
재시작	외부 서비스(UI·FastAPI)에서 사용자 입력 수집 → graph.resume(id, Command(...))	python graph.resume(job_id, Command(update=patch, goto="next_node"))
부모 그래프 점프	하위 서브그래프에서 상위 노드로 이동	Command(graph=Command.PARENT, goto="human_review")
상태 패치	입력값·교정내용을 update={...} 로 주입	수정된 OCR·번역 텍스트 등

무한루프 방지 패턴 예시

@node
async def classify_doc(state):
    outcome, conf = await llm_classify(state.snippet)
    # ❶ 확신도 낮음 → interrupt
    if conf < 0.5:
        return interrupt({ "snippet": state.snippet,
                           "issue": "low_confidence" })
    # ❷ 판별 결과가 'unknown' → human_review로 점프
    if outcome == "unknown":
        return Command(goto="human_review", graph=Command.PARENT)
    # ❸ 정상 분기
    state.doc_type = outcome
    return state

앱개발 백엔드 프레임워크 선택하기

영리0 — Sun, 25 May 2025 20:50:40 +0900

간단한 mvp 프로젝트의 서버를 선택하기 위해 백엔드 프레임워크들을 정리해 보았다.

1. FastAPI

파이썬 문법
제일 많이 쓰는 언어라 문법이 익숙함

주요 특징

비동기 I/O: async/await 문법 지원!
자동 API 문서: 스웨거 문서 지원해 주어 개발 아주 편함!!

장점

생산성: 타입 기반 오류 검출, 자동 문서화로 CRUD API 빠르게 작성 가능
성능: Uvicorn + Starlette 조합으로 동기 파이썬 프레임워크 대비 높은 처리량

단점

생태계 규모: Django·Flask만큼 방대한 커뮤니티·플러그인은 아직 부족 / 정식 개발로 넘어갈때 문제가 될 가능성 높음..
배포 복잡도: Uvicorn, Gunicorn 등 서버 설정이 필요 / AI 모델 적용시 잘 터짐.. + 아주아주 높은 서버 비용

2. NestJS

타입스크립트 기반 Node.js 프레임워크

주요 특징

모듈화 설계: Controller, Service, Module 패턴 강제 (코드 가독성 Good)
의존성 주입(DI): Angular 스타일 DI 컨테이너 내장 (Spring 이랑 비슷?)

장점

큰 규모 프로젝트: 모듈 구분이 명확해 코드 관리·유지보수 용이
TypeScript: 정적 타입 안정성 보장

단점

오버 엔지니어링: 구조가 무겁고 설정 할것이 많음..

하지만 typescript 를 파고싶은 마음이 든다..

3. Spring Boot

제일 많이 써본 프레임워크

주요 특징

자동 설정: 복잡한 xml 설정 없어도 됨!
기능 모듈화: Spring Security, Spring Data, Spring Cloud 등 모듈화 (작년인가 Spring AI 도 나옴!!)
대규모 서비스 지원: 스레드 풀·트랜잭션·배치 처리 기능

장점

성숙도·안정성: 10년 이상 검증된 프레임워크 + 회사에서 제일 많이쓴다?
멀티스레딩: CPU-바운드 작업에 유리

단점

초기 설정 무거움: JDK·Maven/Gradle·서버 설정 등 진입 장벽
런타임 메모리: JVM 기반으로 메모리 사용량이 상대적으로 높음
개발 속도: 간단한 CRUD에도 자바 언어 특성상 코드량이 늘어날 수 있음

아직 결정은 못했지만 개인적으로는 Nest > Fastapi > SpringBoot 순으로 마음에 감

마리오카트 RNN 학습

영리0 — Sun, 18 May 2025 21:45:56 +0900

서론

학교 과제인 Super Mario Kart 에이전트를 학습하기 위해 구현한 순환 신경망(RNN) 기반 모델을 구현했다.

https://github.com/YoonJae00/gym-SuperMarioKart-Snes

GitHub - YoonJae00/gym-SuperMarioKart-Snes: Super Mario Kart Snes integration with OpenAI Retro Gym

Super Mario Kart Snes integration with OpenAI Retro Gym - GitHub - YoonJae00/gym-SuperMarioKart-Snes: Super Mario Kart Snes integration with OpenAI Retro Gym

github.com

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

데이터 수집 및 전처리

Gym-Retro 환경에 SuperMarioKart-Snes 폴더를 등록했다.
Pyglet 키 이벤트를 바인딩해 Z 키와 방향키 입력을 raw 액션 벡터로 기록했다.
한 에피소드가 끝나면 별도 .npz 파일로 저장했다.
데이터 로딩 속도 병목을 해소하기 위해 모든 에피소드 파일을 메모리에 미리 로드하는 MarioFastDataset을 구현했다.

class MarioFastDataset(Dataset):
    def __init__(self, npz_dir, seq_len=10):
        files = sorted(glob.glob(f"{npz_dir}/*.npz"))
        self.seq_len = seq_len
        self.frames_list = []
        self.actions_list = []
        for f in files:
            arr = np.load(f)
            frames  = arr['frames'].astype(np.float32) / 255.0  # 정규화
            actions = arr['actions']
            self.frames_list.append(frames)
            self.actions_list.append(actions)
        self.lengths = [len(a) - seq_len for a in self.actions_list]
        self.cum_lengths = np.cumsum(self.lengths)
    def __len__(self):
        return int(self.cum_lengths[-1])
    def __getitem__(self, idx):
        ep = np.searchsorted(self.cum_lengths, idx, side='right')
        start = idx - (self.cum_lengths[ep-1] if ep>0 else 0)
        frames  = self.frames_list[ep]
        actions = self.actions_list[ep]
        x = frames[start:start+self.seq_len]
        y = actions[start+self.seq_len]
        x = np.expand_dims(x, 1)  # (seq_len,1,84,84)
        return torch.from_numpy(x), torch.tensor(y, dtype=torch.long)

모델 구조

CNN 특징 추출기와 LSTM 순환층을 결합한 MarioRNN 모델을 사용한다.
각 프레임에서 특징 벡터를 추출하고 시퀀스 전체를 LSTM으로 처리해 마지막 시점 출력을 분류한다.

import torch.nn as nn

class MarioRNN(nn.Module):
    def __init__(self, hidden_size=128, n_layers=1, n_actions=3):
        super().__init__()
        self.cnn = nn.Sequential(
            nn.Conv2d(1,16,3,stride=2,padding=1),
            nn.ReLU(),
            nn.Conv2d(16,32,3,stride=2,padding=1),
            nn.ReLU(),
            nn.Flatten()  # (32*21*21)
        )
        feat_size = 32 * 21 * 21
        self.lstm = nn.LSTM(
            input_size=feat_size,
            hidden_size=hidden_size,
            num_layers=n_layers,
            batch_first=True
        )
        self.fc = nn.Linear(hidden_size, n_actions)
    def forward(self, x):
        B,S,C,H,W = x.shape
        x = x.view(B*S, C, H, W)
        feat = self.cnn(x)            # (B*S, feat_size)
        feat = feat.view(B, S, -1)    # (B,S,feat_size)
        out, _ = self.lstm(feat)      # (B,S,hidden)
        return self.fc(out[:, -1, :]) # (B,n_actions)

코드 설명

nn.Conv2d 두 층으로 입력 프레임 특징 벡터 생성
nn.LSTM으로 시퀀스를 순차 처리
out[:, -1, :]로 마지막 시점 은닉 상태 사용
nn.Linear로 행동(직진·좌회전+가속·우회전+가속) 확률 예측

학습 스크립트

Colab T4 환경에서 빠른 학습을 위해 메모리 캐시 데이터셋과 num_workers를 활용한다.
각 epoch마다 loss와 accuracy를 출력해 학습 경과를 모니터링한다.

from tqdm.notebook import tqdm
import time

def train(data_dir, epochs=20, lr=1e-3, batch_size=32, seq_len=15):
    loader = get_fast_loader(data_dir, batch_size, seq_len, num_workers=4)
    print("  총 배치 수:", len(loader))
    print("  Using device:", DEVICE)
    xb,yb = next(iter(loader))
    print("샘플 배치 shapes → x:", xb.shape, "y:", yb.shape)

    model = MarioRNN().to(DEVICE)
    criterion = nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)

    for epoch in range(1, epochs+1):
        print(f"\n▶ Epoch {epoch}/{epochs}")
        total_loss, correct, total = 0,0,0
        for x,y in tqdm(loader, leave=False):
            x,y = x.to(DEVICE), y.to(DEVICE)
            logits = model(x)
            loss = criterion(logits,y)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            total_loss += loss.item()
            preds = logits.argmax(dim=1)
            correct += (preds==y).sum().item()
            total += y.size(0)
        avg_loss = total_loss/len(loader)
        acc = correct/total*100
        print(f"✅ loss={avg_loss:.4f} acc={acc:.2f}%")
    torch.save(model.state_dict(), MODEL_PATH)

테스트 코드

자동화된 단위 테스트로 데이터셋과 모델의 입출력 형태를 검증한다.

pip install pytest
pytest -q

test_dataset.py는 MarioFastDataset와 get_fast_loader의 배치 형태를 확인
test_model.py는 MarioRNN forward 출력 차원 검증

Langgraph 클래스 기반 코드 리팩토링

영리0 — Sun, 11 May 2025 20:02:00 +0900

최근 langgraph를 사용할 때는 단순히 def 함수로 로직을 구현했던 경험이 있었다.

그런데 이번에 투자 AI 모임 코드를 보면서 각 모듈이 클래스를 기반으로 설계되어 있다는 점이 눈에 띄었다.

기존 함수 기반 구현 vs 클래스 기반 구현

함수 기반 코드는 짧고 간단한 작업을 수행할 때 빠르게 작성할 수 있지만 다음과 같은 한계가 있다.

상태 관리의 어려움: 여러 함수에 걸쳐 데이터를 주고받으며 상태를 관리해야 하는 경우 복잡성이 증가함.
코드 중복: 반복되는 로직을 분리하여 관리하기 어렵고, 동일한 코드가 여러 곳에 등장할 수 있음.
유지보수 난이도: 프로젝트 규모가 커질수록 어떤 함수가 어느 역할을 수행하는지 파악하기 어려워짐.

반면 클래스 기반 구현은 관련 변수와 함수를 하나의 객체로 묶어 캡슐화함으로써 다음과 같은 장점을 제공한다.

모듈화: 클래스 내부에 상태와 메서드를 묶어 관리하여 코드 구조를 명확하게 함.
재사용성: 상속과 다형성을 통해 반복되는 로직을 최소화할 수 있음.
테스트 용이성: 객체 단위의 테스트가 가능해지고 Mocking이나 스텁을 활용해 세밀한 단위 테스트 작성이 쉬워짐.

최근 후임자에게 인수인계를 할때 상태관리에 대해 설명하기 복잡한 경우가 있었는데

class 기반 구축이 되어있었다면 어땠을까를 다시한번 생각하게 되었다.

코드 예시

class RewrittenFactorAgent:

    def __init__(self, llm):
        self.llm = llm

    def make_ast(self, state: FactorAgentState):
        print(f"{state['hypothesis']}")
        prompt = ChatPromptTemplate.from_messages(
            [
                ("system", Prompt["system"]),
                ("human", Prompt["human"]),
            ]
        )
        chain = prompt | self.llm
 		# ...생략...

        state["market"] = market_result
        return state

    def get_market_prices(self, tickers):
        # ...생략...
        return {}

[구름톤 유니브] 1. ERD 설계 및 JPA 복습

영리0 — Sun, 4 May 2025 23:14:16 +0900

erd 설계하고 jpa, mybatis 복습하였다.

팀 회의 설계도

요구사항 분석

사용자(Users): 로그인·회원 관리
공연(Shows): 제목, 시간, 장소 등
좌석(Seats): 공연별 구역·행·번호
예약(Reservations): 사용자 ↔ 공연 매핑, 상태 관리
결제(Payments): 예약 단위 결제 정보
매핑 테이블: 예약 ↔ 좌석 (다대다 해소)

개체(Entity) 식별

Users
Shows
Seats
Reservations
ReservationSeats
Payments

관계(Relationship) 정의

Users 1:N Reservations
Shows 1:N Seats
Shows 1:N Reservations
Reservations 1:N ReservationSeats
Seats 1:N ReservationSeats
Reservations 1:1(또는 1:N) Payments

물리 모델링

JPA 정리

엔티티 매핑

@Entity @Table(name = "users") public class User { @Id @GeneratedValue private Long id; private String name; private String email; private String passwordHash; private LocalDateTime createdAt; // getter/setter }

관계 매핑
- OneToMany / ManyToOne
- ManyToMany는 중간 테이블(ReservationSeat)로 풀어내는 것이 권장됨
- fetch 전략 (LAZY vs EAGER) 설정

Repository 인터페이스

public interface ReservationRepository extends JpaRepository<Reservation, Long> { List<Reservation> findByUserId(Long userId); }

JPQL & QueryDSL
- 복잡한 조건이 필요할 땐 @Query로 JPQL 직접 작성
- 타입 안전성을 위해 쿼리DSL 도입 검토
- Q.JPA 와 마이바티스 섞어쓴다 했을때 JPQL 대신 마이바티스 를 쓰는 이유는?
- GPT A. 단순 CRUD 수준이라면 JPA(JPQL)로도 충분하지만,
- 동적·복잡 SQL, DB 특화 기능, 성능 최적화, 레거시 SQL 재사용 등이 필요할 때는 MyBatis를 섞어 쓰는 것이 훨씬 편리하고 효율적입니다.
트랜잭션 관리
- @Transactional 어노테이션으로 서비스 계층 트랜잭션 범위 지정
- 예외 발생 시 롤백 전략 확인 (rollbackFor 등)

MyBatis 정리

XML 기반 설정과 SQL 매핑을 선호할 때 사용

설정 파일 (mybatis-config.xml)

<?xml version="1.0" encoding="UTF-8" ?> <configuration> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <!-- DB 커넥션 설정 --> </dataSource> </environment> </environments> <mappers> <mapper resource="mappers/UserMapper.xml"/> </mappers> </configuration>

매퍼 XML 예시 (UserMapper.xml)

<mapper namespace="com.example.mapper.UserMapper"> <select id="selectUser" resultType="User"> SELECT * FROM users WHERE id = #{id} </select> <insert id="insertUser" useGeneratedKeys="true" keyProperty="id"> INSERT INTO users (name, email, password_hash, created_at) VALUES (#{name}, #{email}, #{passwordHash}, #{createdAt}) </insert> </mapper>

Mapper 인터페이스

public interface UserMapper { User selectUser(Long id); void insertUser(User user); }

장점 vs 단점
- 장점: SQL 제어력 극대화, 복잡도 높은 쿼리 유연
- 단점: XML 관리 부담, 코드↔SQL 분리로 가독성 저하 가능성

결론

JPA Mybatis 섞어야함.

Ibatis 와의 차이점은 뭘까?

[Agent 연습] Claude MCP 알아보기

영리0 — Sun, 13 Apr 2025 20:17:01 +0900

Claude MCP

최근 Anthropic이 개발한 오픈 소스 표준 Claude MCP(Model Context Protocol)를 공부하였다.

MCP는 AI 모델이 외부 데이터 소스 및 다양한 도구와 연결되도록 하는 프로토콜 (Like USB-C 포트) 임

원래는 function calling 기법으로 프로젝트를 기획했지만 이번에 MCP 방식으로 마이그래이션하기로 결정

MCP 개요 및 구성

MCP는 AI 모델과 외부 시스템이 원활하게 통신할 수 있도록 설계되었음.

1. MCP Host

Claude Desktop, IDE, LangGraph 에이전트 등 MCP를 활용하는 주체.
사용자 요청을 MCP 형식으로 변환.

2. MCP Server

파일 시스템, 데이터베이스, API 등 특정 기능을 제공하는 프로그램.
표준화된 인터페이스를 통해 도구 실행을 지원.

3. MCP Client

Host와 Server 간 통신을 중개하는 프로토콜 변환.
SSE(실시간 스트리밍)와 Stdio(표준 입출력) 등 다양한 전송 방식을 지원함.

LangGraph와의 통합 진행

MCP는 LangChain-MCP Adapters를 통해 LangGraph 에이전트와 쉽게 통합됨.

MCP 서버 설정 예시

수학 연산 서버 예시

# math_server.py
from mcp.server.fastmcp import FastMCP
mcp = FastMCP("Math")

@mcp.tool()
def add(a: int, b: int) -> int:
    return a + b

mcp.run(transport="stdio")

위 코드를 통해 간단한 수학 연산 기능을 MCP 서버에 탑재 가능

LangGraph 에이전트 구성 예시

아래와 같이 LangGraph 에이전트에 MCP 클라이언트를 연결

from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent

async with MultiServerMCPClient({
    "math": {"command": "python", "args": ["math_server.py"], "transport": "stdio"}
}) as client:
    agent = create_react_agent(model, client.get_tools())
    response = await agent.ainvoke({"messages": "3+5*2 계산해줘"})

이 방식을 사용하여 JSON 설정으로 실시간 도구 추가 및 제거를 쉽게 관리 가능

실제 적용 사례

MCP 도입 후 활용 사례는 다양하게 진행됨.

자동화 워크플로우
Git 리포지토리 분석 → README 자동 생성 → Slack 알림 전송 등의 작업을 자동화함.
데이터 분석
Postgres DB 쿼리 수행 → 데이터 시각화 생성 → 보고서 작성 등 단계를 연계하여 진행함.
실시간 협업
다중 MCP 서버(예: ChatGPT와 Claude)를 LangGraph로 오케스트레이션하여 실시간 협업 환경을 구성함.

function calling 방식에서 MCP 방식으로 마이그래이션 결정

초기에는 vllm function calling 기법을 사용하여 프로젝트를 진행할 계획이었음.

그러나 도구 연동의 복잡성과 설정 관리의 어려움을 경험함. 이에 따라 보다 표준화되고 유연한 MCP 방식을 도입하기로 결정함.

MCP 방식의 주요 장점은 아래와 같음.

표준화된 인터페이스 제공: 다양한 서버와 클라이언트, 도구를 일관된 방식으로 연결함.
설정 시간 절감: JSON 기반의 도구 관리 덕분에 설정 및 배포 시간이 대폭 단축됨.
혼합 전송 방식 지원: SSE와 Stdio를 혼용하여 실시간 스트리밍과 기본 입출력 모두 지원함.
확장성 및 신뢰성: 엔터프라이즈 시스템 연동에 대해 이미 검증됨.

마무리

MCP 방식으로의 마이그래이션을 통해 기존의 vllm 방식에서 벗어나, 더욱 표준화된 도구 통합 시스템을 구축 가능하다!

초기 설정은 복잡할 수 있으나, 한 번 구축해두면 다양한 외부 도구와의 연동 및 AI 모델 기능 확장이 원활하다!!

소설 캐릭터 정보 추출 & 대화 토이프로젝트 (Book Buddy)

영리0 — Sun, 24 Nov 2024 23:34:27 +0900

소설 캐릭터 챗봇 개발기: 텍스트 처리부터 채팅 구현까지

웹소설을 읽다가 궁금한 점이 생기면 바로 캐릭터와 대화하면서 확인하고 싶었습니다. 소설을 읽기 전 등장인물들과 대화할 수 있는 기능을 만들고자 했습니다.

달빛조각사 / 주인공

https://github.com/YoonJae00/BookBuddy

GitHub - YoonJae00/BookBuddy: 소설원문 기반 채팅 app

소설원문 기반 채팅 app. Contribute to YoonJae00/BookBuddy development by creating an account on GitHub.

github.com

1. 텍스트 분할 (Text Splitting)

소설 텍스트를 효율적으로 처리하기 위해 청크 단위로 분할했습니다:

            # 2. 텍스트 분할
            chunks = self.text_splitter.split_text(content)
            if not chunks:
                raise NovelProcessingError("Failed to split text into chunks")

이 과정에서 고려한 점들:

문맥 유지를 위한 적절한 청크 크기 설정
청크 간 오버랩으로 문맥 연결성 확보
메모리 효율성 고려

https://smith.langchain.com/public/8bc2632b-70ea-4471-9e1c-0ae45b153331/r

LangSmith

smith.langchain.com

2. 캐릭터 추출 (Character Extraction)

분할된 텍스트에서 등장인물 정보를 추출합니다:

            # 1. 초기 캐릭터 식별
            characters = await self._identify_characters(content, novel_id)
            if not characters:
                raise NovelProcessingError("No characters found in the novel")

            for char in characters:
                self.name_resolver.add_character(char['full_name'], char['aliases'])
                self.logger.log_character_found(char['full_name'], char)

                # 캐릭터 정보 저장 (동기식)
                db.save_character({
                    'id': str(uuid.uuid4()),
                    'novel_id': novel_id,
                    **char
                })

추출하는 캐릭터 정보:

이름과 별칭
성격 특성
배경 정보
관계도
역할

이름/성격/특성

상세 등등

관계

3. 이벤트 추출 (Event Extraction)

캐릭터들의 행동과 사건을 추출합니다:

            # 3. 각 청크 처리
            all_events = []
            for i, chunk in enumerate(chunks):
                try:
                    normalized_chunk = self._normalize_names(chunk)
                    events = await self._extract_events(normalized_chunk, i)
                    for event in events:
                        # 이벤트 저장 (동기식)
                        event['id'] = str(uuid.uuid4())
                        event['novel_id'] = novel_id
                        db.save_event(event)
                        self.logger.log_event_extracted(event['summary'], i)
                    all_events.extend(events)
                except Exception as e:
                    self.logger.log_error(f"Error processing chunk {i}", {"error": str(e)})
                    continue

이벤트 데이터 구조:

사건 요약
관련 캐릭터
발생 위치(챕터)
중요도
감정 상태

https://smith.langchain.com/public/8cc0e5b5-c393-4745-8f09-a237c7856b8d/r

LangSmith

smith.langchain.com

4. 채팅 시스템 구현

추출된 정보를 바탕으로 캐릭터와의 대화를 구현합니다:

class CharacterChatbot:
    def __init__(self, character_data: Dict, events: List[Dict], settings, user_id: str):
        self.character = character_data
        self.events = events
        self.user_id = user_id
        self.db = DatabaseService()
        self.vector_store = VectorStore(settings)
        self.llm = ChatOpenAI(
            temperature=0.7,
            model="gpt-4o-mini",
            openai_api_key=settings.OPENAI_API_KEY
        )
        )
        self.chat_history = ChatMessageHistory()
        # 응답 생성
        # 이전 대화 기록 로드
        history = self.db.get_chat_history(
            character_id=character_data['id'],
            user_id=user_id
        )
            성격: {character[personality_traits]}
        for msg in history:
            if msg['role'] == 'user':
                self.chat_history.add_user_message(msg['content'])
            else:
                self.chat_history.add_ai_message(msg['content'])

채팅 시스템의 주요 특징:

캐릭터 성격 반영
관련 이벤트 참조
대화 맥락 유지
이전 대화 기록 활용

데이터 구조 설계

캐릭터 정보

    def save_character(self, character_data: Dict) -> None:
        """캐릭터 정보 저장"""
        try:
            character_id = character_data.get('id')
            if not character_id:
                raise Exception("Character ID is required")
                .where('novel_id', '==', novel_id)\
            self.db.collection('characters')\
                .document(character_id)\
                .set(character_data)
                .where('novel_id', '==', novel_id)\
        except Exception as e:
            raise Exception(f"Failed to save character: {str(e)}")

이벤트 저장

    def save_event(self, event_data: Dict) -> None:
        """이벤트 정보 저장"""
        try:
            self.db.collection('events').document(event_data['id']).set(event_data)
        except Exception as e:
            raise Exception(f"Failed to save event: {str(e)}")

대화 기록

    def save_chat_history(self, character_id: str, user_id: str, message: Dict) -> None:
        """대화 기록 저장"""
        try:
            self.db.collection('chat_history').add({
                'character_id': character_id,
                'user_id': user_id,
                'content': message['content'],
                'role': message['role'],
                'timestamp': firestore.SERVER_TIMESTAMP
            })
        except Exception as e:
            print(f"Failed to save chat history: {str(e)}")

개발 과정에서 배운 점

텍스트 처리 최적화
- 전체 텍스트를 저장할 필요 없이, 필요한 정보만 추출하여 저장
- 벡터 검색으로 관련 컨텍스트 효율적 검색
캐릭터 정보 구조화
- 캐릭터의 다양한 특성을 체계적으로 저장
- 관계 정보를 통한 캐릭터 간 상호작용 지원
이벤트 기반 기억
- 캐릭터의 경험과 기억을 이벤트 단위로 관리
- 대화 중 관련 이벤트 참조로 맥락 유지
실시간 대화 처리
- 대화 기록 유지로 일관성 있는 대화 흐름
- 캐릭터 특성에 맞는 응답 생성

향후 개선 방향

텍스트 분석 고도화
- 더 정확한 캐릭터 정보 추출
- 감정 분석 추가
대화 품질 향상
- 캐릭터 성격 더 정교하게 반영
- 다중 캐릭터 대화 지원
사용자 경험 개선
- 실시간 피드백 반영
- 대화 컨텍스트 시각화

Agent 만들기 [8] - 분신 성격 업데이트: LLM과 상호작용 분석을 활용한 페르소나 발전

영리0 — Thu, 21 Nov 2024 12:31:29 +0900

OpenAI의 GPT-4o 모델과 Firebase, Redis, Firestore, LangChain 활용.

주요 동작 원리

1. 상호작용 데이터 수집

Redis와 Firestore를 사용하여 사용자의 대화와 행동 데이터를 저장

async def store_user_interaction(uid: str, interaction_data: dict):
    # Redis 및 Firestore에 상호작용 저장
    ...

2. LLM 기반 분석

LangChain을 활용해 OpenAI GPT-4 모델로 사용자 상호작용 데이터를 분석.

analysis_template = """
당신은 사용자의 분신 페르소나를 발전시키는 전문가입니다.
...
"""

3. 페르소나 업데이트

분석 결과를 Firestore에 저장된 기존 페르소나와 결합하여 업데이트.

async def analyze_and_update_persona(uid: str):
    # 상호작용 데이터 분석 및 Firestore 업데이트
    ...

상호작용 데이터 예시

분석에 사용된 상호작용 데이터는 다음과 같이 Redis에 저장:

[
    {"timestamp": "2024-11-21T10:00:00", "type": "message", "message": "안녕! 오늘 기분 어때?"},
    {"timestamp": "2024-11-21T10:05:00", "type": "message", "message": "나는 새로운 프로젝트를 시작했어."}
]

업데이트 결과

다음과 같이 페르소나를 업데이트:

nest.js + react (jotai) 개발 [2] - jotai 비동기 처리

영리0 — Tue, 19 Nov 2024 15:50:37 +0900

1. 비동기 Atom

기본적인 비동기 Atom

// 가장 심플한 비동기 atom
const asyncAtom = atom(async () => {
  const response = await fetch('https://api.example.com/data');
  return response.json();
});

redux + thunk 처럼 길지 않고 매우 편리한거 같음!

로딩/에러 상태 처리

const todoWithStatusAtom = atom(async (get) => {
  try {
    const data = await get(asyncAtom);
    return { status: 'success', data };
  } catch (error) {
    return { status: 'error', error };
  }
});

2. 실제 로그인 구현하기

Auth Atom 만들기

interface LoginResponse {
    accessToken?: string;
}

interface LoginRequest {
    userId: string;
    userPassword: string;
}

// 인증 상태 저장용 atom
export const authAtom = atom<LoginResponse | null>(null);

// 로그인 처리용 atom
export const loginAtom = atom(
    (get) => get(authAtom),
    async (get, set, payload: LoginRequest) => {
        await axios.post<LoginResponse>('/auth/login', payload)
            .then((res) => {
                set(authAtom, res.data);
            })
    }
);

사용하기

function LoginComponent() {
    const [auth] = useAtom(authAtom);
    const [, login] = useAtom(loginAtom);

    const handleLogin = async () => {
        await login({
            userId: "user123",
            userPassword: "pass123"
        });
    }
}

3. useEffect vs Jotai 비동기 Atom

useEffect(() => {
    const fetchData = async () => {
        try {
            setLoading(true);
            const response = await axios.get('/api/data');
            setData(response.data);
        } catch (error) {
            setError(error);
        } finally {
            setLoading(false);
        }
    };

    fetchData();
}, []);

const dataAtom = atom(async () => {
    const response = await axios.get('/api/data');
    return response.data;
});

// 컴포넌트에서
const [data] = useAtom(dataAtom);

훨씬 짧아짐!

4. 왜 Jotai가 더 좋을까?

보일러플레이트 감소
- loading, error 상태 관리 자동화
- try-catch 로직 단순화
상태 공유 용이
- 여러 컴포넌트에서 같은 데이터 접근 가능
- 캐싱 자동 지원
TypeScript 친화적
- 타입 추론이 자연스럽게 동작
- 타입 안정성 보장

nest.js + react (jotai) 개발 [1] - jotai 에 대해..

영리0 — Tue, 19 Nov 2024 11:52:01 +0900

Jotai가 뭔데?

일단 Jotai는 React 상태관리 라이브러리임.

이름이 일본어로 '상태'라는 뜻
심플하고 직관적인거 같음.

사용 영상

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

기본 사용법

import { atom, useAtom } from 'jotai';

const textAtom = atom('안녕하세요'); // 초기값 설정

function Component() {
  const [text, setText] = useAtom(textAtom);
  // useState랑 비슷하게 생겼지?
}

useState랑 뭐가 다른데?

처음에는 그냥 useState랑 비슷하네? 했는데 완전 다름.
제일 큰 차이점은 전역 상태 관리가 가능

예를 들어서:

useState는 컴포넌트 안에서만 씀
Jotai는 여러 컴포넌트에서 같은 상태 공유 가능

// atoms/themeAtom.ts
const isDarkAtom = atom(false);

// components/Header.tsx
function Header() {
  const [isDark] = useAtom(isDarkAtom);
  // 여기서 다크모드 상태 사용
}

// components/Footer.tsx
function Footer() {
  const [isDark] = useAtom(isDarkAtom);
  // 여기서도 같은 상태 사용 가능!
}

언제 써야 할까?

모든 걸 Jotai로 하면 안 됨 중요

Jotai 쓰기 좋은 경우:

여러 컴포넌트에서 같이 쓰는 상태 (다크모드, 로그인 정보 등)
복잡한 상태 로직이 필요할 때
props로 계속 넘기기 귀찮은 경우 (props drilling 피하기)

그냥 useState 쓰는게 나은 경우:

컴포넌트 안에서만 쓰는 임시 상태
간단한 토글이나 폼 입력값
모달 열고 닫기같은 UI 상태

Jotai의 더 고급 기능들 (비동기 처리, 파생 상태 등) 공부해봐야겠음.