> ## Documentation Index
> Fetch the complete documentation index at: https://docs.gravitex.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# LangChain

> LangChain 프레임워크 연동 가이드

## 소개

LangChain은 언어 모델 애플리케이션을 구축하기 위한 강력한 프레임워크입니다. **GravitexAI**와 연동하면 LangChain에서 다양한 AI 모델을 유연하게 호출할 수 있습니다.

## 빠른 시작

### 1. 의존성 설치

```bash theme={null}
pip install langchain langchain-openai
```

### 2. 기본 설정

```python theme={null}
import os
from langchain_openai import ChatOpenAI

os.environ["OPENAI_API_KEY"] = "Your GravitexAI Key"
os.environ["OPENAI_BASE_URL"] = "https://api.gravitex.ai/v1"

llm = ChatOpenAI(
    model="gpt-3.5-turbo",
    temperature=0.7
)
```

## 핵심 기능

### 1. 기본 채팅

```python theme={null}
from langchain.schema import HumanMessage, SystemMessage

messages = [
    SystemMessage(content="You are a helpful assistant"),
    HumanMessage(content="Introduce Python's main features")
]

response = llm.invoke(messages)
print(response.content)
```

### 2. 대화 체인 (메모리 포함)

```python theme={null}
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain

memory = ConversationBufferMemory()
conversation = ConversationChain(llm=llm, memory=memory, verbose=True)

conversation.predict(input="I want to learn machine learning")
conversation.predict(input="Recommend some beginner resources")
```

### 3. 문서 Q\&A (RAG)

```python theme={null}
from langchain.document_loaders import TextLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.chains import RetrievalQA

embeddings = OpenAIEmbeddings(
    api_key="Your GravitexAI Key",
    base_url="https://api.gravitex.ai/v1"
)

loader = TextLoader("document.txt")
documents = loader.load()

text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
texts = text_splitter.split_documents(documents)

vectorstore = FAISS.from_documents(texts, embeddings)

qa = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever()
)

result = qa.run("What are the key concepts in the document?")
```

## 모델 전환

```python theme={null}
gpt4 = ChatOpenAI(
    model="gpt-4",
    api_key="Your GravitexAI Key",
    base_url="https://api.gravitex.ai/v1"
)

claude = ChatOpenAI(
    model="claude-opus-4-5-20251101",
    api_key="Your GravitexAI Key",
    base_url="https://api.gravitex.ai/v1"
)
```

## 고급 애플리케이션

### 1. Agent 시스템

```python theme={null}
from langchain.agents import create_openai_functions_agent, AgentExecutor
from langchain.tools import Tool
from langchain import hub

def get_weather(location: str) -> str:
    return f"Weather in {location}: Sunny, 25°C"

weather_tool = Tool(
    name="Weather",
    func=get_weather,
    description="Get weather info for a location"
)

prompt = hub.pull("hwchase17/openai-functions-agent")
agent = create_openai_functions_agent(llm, [weather_tool], prompt)
agent_executor = AgentExecutor(agent=agent, tools=[weather_tool])

result = agent_executor.invoke({"input": "What's the weather in Beijing?"})
```

### 2. 배치 처리

```python theme={null}
prompts = ["Explain AI", "What is ML", "Deep learning applications"]

responses = llm.batch([HumanMessage(content=p) for p in prompts])

for response in responses:
    print(response.content)
```

### 3. 스트리밍 출력

```python theme={null}
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler

streaming_llm = ChatOpenAI(
    model="gpt-3.5-turbo",
    streaming=True,
    callbacks=[StreamingStdOutCallbackHandler()]
)

streaming_llm.invoke("Write a poem about spring")
```

### 4. 비용 모니터링

```python theme={null}
from langchain.callbacks import get_openai_callback

with get_openai_callback() as cb:
    response = llm.invoke("Hello, introduce LangChain")
    print(f"Tokens: {cb.total_tokens}")
    print(f"Cost: ${cb.total_cost:.6f}")
```

## 모범 사례

### 모델 선택

| 작업     | 모델                         | 이유       |
| ------ | -------------------------- | -------- |
| 간단한 채팅 | gpt-3.5-turbo              | 빠르고 저렴   |
| 복잡한 추론 | gpt-4                      | 높은 정확도   |
| 장문     | claude-3-opus              | 더 긴 컨텍스트 |
| 창작     | claude-sonnet-4-5-20250929 | 유창한 생성   |

### 비용 최적화

```python theme={null}
class CostOptimizedLLM:
    def __init__(self):
        self.cheap_model = ChatOpenAI(model="gpt-3.5-turbo")
        self.premium_model = ChatOpenAI(model="gpt-4")
    
    def smart_invoke(self, message, complexity="low"):
        model = self.premium_model if complexity == "high" else self.cheap_model
        return model.invoke(message)
```

### 캐싱

```python theme={null}
from langchain.cache import InMemoryCache
from langchain.globals import set_llm_cache

set_llm_cache(InMemoryCache())

response1 = llm.invoke("What is AI?")
response2 = llm.invoke("What is AI?")  # Uses cache
```

### 비동기 처리

```python theme={null}
import asyncio
from langchain_openai import AsyncChatOpenAI

async def async_chat():
    async_llm = AsyncChatOpenAI(
        model="gpt-3.5-turbo",
        api_key="Your GravitexAI Key",
        base_url="https://api.gravitex.ai/v1"
    )
    response = await async_llm.ainvoke("Async generated content")
    return response.content

result = asyncio.run(async_chat())
```

## 배포

### 프로덕션 설정

```python theme={null}
import os
from langchain_openai import ChatOpenAI

class ProductionLLM:
    def __init__(self):
        self.llm = ChatOpenAI(
            model=os.getenv("LLM_MODEL", "gpt-3.5-turbo"),
            temperature=float(os.getenv("LLM_TEMPERATURE", "0.7")),
            max_tokens=int(os.getenv("LLM_MAX_TOKENS", "1000")),
            request_timeout=int(os.getenv("LLM_REQUEST_TIMEOUT", "60"))
        )
    
    def chat(self, message):
        try:
            return self.llm.invoke(message)
        except Exception:
            return "Sorry, service unavailable"
```

### 재시도 메커니즘

```python theme={null}
import time
from functools import wraps

def retry_llm_call(max_retries=3, delay=1):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_retries - 1:
                        raise e
                    time.sleep(delay * (2 ** attempt))
            return None
        return wrapper
    return decorator

@retry_llm_call(max_retries=3)
def robust_llm_call(llm, message):
    return llm.invoke(message)
```