1
pip install -U ollama langchain-core langchain-ollama langchain-community

1
2
ollama pull llama3.1:8b
ollama pull llava-llama3

1
ollama list

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
from langchain_ollama import ChatOllama
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# 모델 로드
llm = ChatOllama(model="llama3.1:8b", temperature=0.7)

# 프롬프트 템플릿 설정 (선택 사항이지만 권장)
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    ("user", "{input}")
])

# 출력 파서 설정 (LLM의 출력을 문자열로 파싱)
output_parser = StrOutputParser()

# 체인 구성
chain = prompt | llm | output_parser

# 답변 요청
question = "대한민국의 수도는 어디인가요?"
response = chain.invoke({"input": question})

# 답변 출력
print(f"질문: {question}")
print(f"답변: {response}")

1
2
3
4
5
6
messages = [
  ("system", "You are a helpful assistant."),
  ("human", "What's the weather in Seoul?")
]

llm.invoke(messages)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from langchain_core.prompts import ChatPromptTemplate
# from langchain_community.chat_models import ChatOllama
from langchain_ollama import ChatOllama

# 1. 프롬프트 템플릿 정의
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a translator from English to Korean."),
    ("human", "{sentence}")
])

# 2. LLM 모델 정의 (Ollama 기반)
llm = ChatOllama(model="llama3.1:8b")

# 3. 체인 구성
chain = prompt | llm

# 4. 실행
result = chain.invoke({"sentence": "I love programming."})
print(result.content)  # 나는 프로그래밍을 좋아합니다.

1
2
3
4
5
6
from langchain_ollama import ChatOllama

llm = ChatOllama(model="llama3.1:8b")

response = llm.invoke("Where is the nearest train station in Kingston, London?")
print(response.content)

1
2
3
4
5
6
7
8
9
10
Kingston upon Thames has several train stations. The two main ones are:

1. **Kingston Railway Station**: This is the primary railway station serving Kingston and is located on London Road, near the town centre. It's operated by Southern and Thameslink trains.
2. **Norbiton Station** (about 0.8 miles from Kingston Centre): Although not in the very heart of Kingston, this station offers a convenient alternative for those living nearby.

Both stations offer frequent services to central London, as well as other destinations in South London and beyond.

To get to either of these stations, you can use online journey planners like National Rail or Transport for London (TfL) Journey Planner.

If you're looking for the nearest train station from a specific location within Kingston, I'd be happy to help with more precise directions!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
from langchain_core.tools import tool
from langchain_ollama import ChatOllama

@tool
def check_balance(account_id: int) -> str:
    """Check the balance of a bank account by its ID."""
    return f"Account {account_id} has $5,000."

llm = ChatOllama(model="llama3.1:8b").bind_tools([check_balance])

response = llm.invoke("Check the balance for account 1234.")

print("########################")
print(response.tool_calls)
print("########################")

# tool_calls만 있으면, LLM이 판단만 했다는 뜻 → 실제 실행은 우리가 직접
if response.tool_calls:
    for call in response.tool_calls:
        tool_name = call["name"]
        args = call["args"]

        # 여기서 실제 실행
        if tool_name == "check_balance":
            result = check_balance.invoke(args)
            print(f"✅ Tool 실행 결과: {result}")

1
2
3
4
5
6
7
8
9
[유저 입력]
  ↓
LLM 분석 → "도구가 필요해!"
  ↓
tool_calls 반환 (함수 이름 + 파라미터)
  ↓
개발자가 직접 tool 실행 (invoke)
  ↓
실행 결과 출력 or 후속 대화로 전달

1
2
3
4
5
6
7
8
9
10
########################
[
  {'name': 'check_balance', 
   'args': {'account_id': 1234}, 
   'id': 'f62b110c-9d9c-4500-a753-4b5afcf2dfd1', 
   'type': 'tool_call'}
]
########################

✅ Tool 실행 결과: Account 1234 has $5,000.

1
2
3
4
5
[entry: llm_call]
       ↓
(tool_call 있음?) ── Yes → [tool_execute] → [llm_continue] → END  
         │
         └── No  → [end_or_output] → END

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
from typing import TypedDict, List, Dict
from langgraph.graph import StateGraph, END
from langchain_core.tools import tool
from langchain_ollama import ChatOllama

@tool
def check_balance(account_id: int) -> str:
    """Check the balance of a bank account by its ID."""
    return f"Account {account_id} has $5,000."

llm = ChatOllama(model="llama3.1:8b").bind_tools([check_balance])

# -----------------------
# 상태 정의
# -----------------------

class AgentState(TypedDict):
    messages: List[Dict]
    tool_calls: List[Dict]
    tool_results: List[Dict]

# -----------------------
# 노드 함수 정의
# -----------------------

def llm_call(state: AgentState) -> AgentState:
    response = llm.invoke(state["messages"])
    return {
        "messages": state["messages"] + [response],
        "tool_calls": response.tool_calls,
        "tool_results": []
    }

def tool_execute(state: AgentState) -> AgentState:
    results = []
    for call in state["tool_calls"]:
        if call["name"] == "check_balance":
            result = check_balance.invoke(call["args"])
            results.append({"tool": call["name"], "output": result})
    return {**state, "tool_results": results}

def llm_continue(state: AgentState) -> AgentState:
    tool_msgs = [
        {"role": "tool", "tool_call_id": call["id"], "content": res["output"]}
        for call, res in zip(state["tool_calls"], state["tool_results"])
    ]
    response = llm.invoke(state["messages"] + tool_msgs)
    return {"messages": state["messages"] + tool_msgs + [response]}

def return_as_is(state: AgentState) -> AgentState:
    return state  # LLM만 호출 후 끝낼 경우

# -----------------------
# 그래프 구성
# -----------------------

builder = StateGraph(state_schema=AgentState)

builder.add_node("llm_call", llm_call)
builder.add_node("tool_execute", tool_execute)
builder.add_node("llm_continue", llm_continue)
builder.add_node("skip_tool", return_as_is)

builder.set_entry_point("llm_call")

# 조건 분기 추가 (tool_call이 있는지 여부에 따라)
def has_tool(state: AgentState) -> str:
    return "yes" if state["tool_calls"] else "no"

builder.add_conditional_edges(
    "llm_call",
    has_tool,
    {
        "yes": "tool_execute",
        "no": "skip_tool"
    }
)

builder.add_edge("tool_execute", "llm_continue")
builder.add_edge("llm_continue", END)
builder.add_edge("skip_tool", END)

graph = builder.compile()
graph

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
from langchain_ollama import ChatOllama

# LLM 초기화
llm = ChatOllama(model="llama3.1:8b")

# 1. 시스템 메시지 정의
system_message = SystemMessage(content="You are a helpful AI assistant who remembers the last few turns of our conversation.")

# 2. 대화 내용(Chat History)을 저장할 리스트
chat_history = []

# 3. LLM에 전달할 최근 메시지 개수 설정 (예: 최근 4개 메시지 = 2턴의 대화)
#    이 값을 조절하여 얼마나 많은 과거 대화를 LLM이 기억하게 할지 결정할 수 있습니다.
#    (시스템 메시지는 항상 포함되므로, 실제로는 이 개수 + 1개의 메시지가 전달됨)
MAX_HISTORY_MESSAGES = 4

print("AI Assistant: 안녕하세요! 대화를 시작해 보세요. (종료하려면 'quit'을 입력하세요)")

while True:
    user_input = input("나: ")
    if user_input.lower() == 'quit':
        print("AI Assistant: 대화를 종료합니다.")
        break

    current_human_message = HumanMessage(content=user_input)

    # 4. LLM에 전달할 메시지 리스트 구성
    messages_to_llm = [system_message] # 항상 시스템 메시지로 시작

    # 최근 대화 기록 추가 (가장 오래된 것부터 순서대로)
    # chat_history에서 최근 MAX_HISTORY_MESSAGES 개수만큼 가져옴
    recent_history = chat_history[-MAX_HISTORY_MESSAGES:]
    messages_to_llm.extend(recent_history)

    messages_to_llm.append(current_human_message) # 현재 사용자 메시지 추가

    # 디버깅: LLM에 전달되는 메시지 확인
    # print("\n--- LLM에 전달되는 메시지 ---")
    # for msg in messages_to_llm:
    #     print(f"{msg.type}: {msg.content}")
    # print("---------------------------\n")

    # 5. LLM 호출
    ai_response = llm.invoke(messages_to_llm)

    print(f"AI Assistant: {ai_response.content}")

    # 6. 현재 사용자의 메시지와 AI의 응답을 chat_history에 추가
    chat_history.append(current_human_message)
    chat_history.append(ai_response) # AIMessage 객체 그대로 추가

    # (선택적) 너무 많은 히스토리가 쌓이는 것을 방지하기 위해 오래된 히스토리 제거
    # 예를 들어, chat_history의 최대 길이를 10개 메시지 (5턴)로 유지
    # MAX_TOTAL_HISTORY = 10
    # if len(chat_history) > MAX_TOTAL_HISTORY:
    #     chat_history = chat_history[-MAX_TOTAL_HISTORY:]

1
2
3
4
5
6
7
8
9
10
11
12
13
from langchain_community.chat_models import ChatOllama

# streaming=True로 LLM을 초기화합니다.
llm = ChatOllama(model="llama3.1:8b", streaming=True)

print("AI가 이야기를 시작합니다...")
# llm.stream()을 사용하여 응답을 스트리밍으로 받습니다.
for chunk in llm.stream("Tell me a story about a fox and a cat."):
    # chunk.content에 현재 수신된 텍스트 조각이 들어있습니다.
    # end=""는 print 함수가 자동으로 줄바꿈하는 것을 방지합니다.
    # flush=True는 출력 버퍼를 즉시 비워 화면에 바로 표시되도록 합니다.
    print(chunk.content, end="", flush=True)
print("\n이야기 끝!")