스트리밍과 실시간 응답

일반 응답:
사용자 → 요청 → ... 8초 대기 ... → 전체 응답 받음
사용자 체감: "느려"

스트리밍:
사용자 → 요청 → 토큰 1 (0.1초) → 토큰 2 (0.2초) → ...
사용자 체감: "빠르다, ChatGPT처럼"

from langchain_anthropic import ChatAnthropic

llm = ChatAnthropic(
    model="claude-sonnet-4-6",
    streaming=True,
)

# stream() — 토큰 단위 iterator
for chunk in llm.stream("Python 반복문 5종을 비교해줘"):
    print(chunk.content, end="", flush=True)
# 토큰 단위로 즉시 출력 (ChatGPT 같은 경험)

import asyncio

async def stream_response(query):
    async for chunk in llm.astream(query):
        print(chunk.content, end="", flush=True)


asyncio.run(stream_response("LangGraph 시작 방법은?"))

# pip install fastapi uvicorn
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from langchain_anthropic import ChatAnthropic

app = FastAPI()
llm = ChatAnthropic(model="claude-sonnet-4-6", streaming=True)


@app.get("/chat")
async def chat(q: str):
    async def generate():
        async for chunk in llm.astream(q):
            # SSE 형식: "data: <content>\n\n"
            yield f"data: {chunk.content}\n\n"
        yield "data: [DONE]\n\n"

    return StreamingResponse(
        generate(),
        media_type="text/event-stream",
    )


# 실행: uvicorn app:app --reload
# 클라이언트 (브라우저):
# const evt = new EventSource("/chat?q=Hello");
# evt.onmessage = (e) => console.log(e.data);

// 클라이언트 측 스트리밍 처리
'use client';
import { useState } from 'react';

export function ChatStream() {
  const [response, setResponse] = useState('');
  const [loading, setLoading] = useState(false);

  const send = async (q: string) => {
    setLoading(true);
    setResponse('');

    const evt = new EventSource(`/chat?q=${encodeURIComponent(q)}`);
    evt.onmessage = (e) => {
      if (e.data === '[DONE]') {
        evt.close();
        setLoading(false);
        return;
      }
      setResponse(prev => prev + e.data);
    };
    evt.onerror = () => {
      evt.close();
      setLoading(false);
    };
  };

  return (
    <div>
      <button onClick={() => send('Hello')} disabled={loading}>
        {loading ? '응답 중...' : '시작'}
      </button>
      <div>{response}</div>
    </div>
  );
}

from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
from langchain_core.prompts import ChatPromptTemplate

prompt = ChatPromptTemplate.from_template("""
컨텍스트: {context}
질문: {question}
답변:""")

chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

# 체인 자체도 stream()
async for chunk in chain.astream("LangChain 시작 방법?"):
    print(chunk, end="", flush=True)

from langchain_core.callbacks import AsyncCallbackHandler

class TokenCounter(AsyncCallbackHandler):
    def __init__(self):
        self.tokens = 0

    async def on_llm_new_token(self, token: str, **kwargs):
        self.tokens += 1


counter = TokenCounter()

async for chunk in llm.astream(
    "LangChain은 무엇?",
    callbacks=[counter],
):
    print(chunk.content, end="")

print(f"\n총 토큰: {counter.tokens}")

async def safe_stream(query):
    try:
        async for chunk in llm.astream(query):
            yield chunk.content
    except Exception as e:
        yield f"\n\n[에러: {e}]"


# FastAPI에서 SSE 종료 처리
async def generate_safe(q):
    try:
        async for chunk in llm.astream(q):
            yield f"data: {chunk.content}\n\n"
        yield "data: [DONE]\n\n"
    except Exception as e:
        yield f"data: [ERROR: {e}]\n\n"
    finally:
        # 클린업
        pass