# Buat virtual environment
python -m venv agent-env
source agent-env/bin/activate  # Linux/Mac
agent-env\Scripts\activate     # Windows

# Install packages utama
pip install langchain langchain-openai
pip install langchain-community
pip install python-dotenv
pip install duckduckgo-search
pip install beautifulsoup4 requests

OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxx

from dotenv import load_dotenv
import os

load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")
print("API key loaded!") # Tes apakah berhasil

from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage

# Inisialisasi model
llm = ChatOpenAI(
    model="gpt-4o-mini",  # Model paling hemat
    temperature=0
)

# Tes sederhana
response = llm.invoke([
    HumanMessage(content="Halo! Jawab singkat saja.")
])

print(response.content)

from langchain.tools import tool
from duckduckgo_search import DDGS
import requests

@tool
def search_web(query: str) -> str:
    """Cari informasi dari internet menggunakan DuckDuckGo."""
    with DDGS() as ddgs:
        results = list(ddgs.text(query, max_results=3))
    
    output = ""
    for r in results:
        output += f"Judul: {r['title']}\n"
        output += f"URL: {r['href']}\n"
        output += f"Isi: {r['body']}\n\n"
    
    return output

@tool
def calculate(expression: str) -> str:
    """Hitung ekspresi matematika sederhana. Contoh: '2 + 2' atau '10 * 5'"""
    try:
        result = eval(expression)
        return f"Hasil: {result}"
    except:
        return "Error: ekspresi tidak valid"

from langchain_openai import ChatOpenAI
from langchain.agents import create_react_agent, AgentExecutor
from langchain import hub
from tools import search_web, calculate

# 1. Inisialisasi LLM
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

# 2. Daftar tools yang bisa digunakan agent
tools = [search_web, calculate]

# 3. Load prompt ReAct dari LangChain Hub
prompt = hub.pull("hwchase17/react")

# 4. Buat agent
agent = create_react_agent(llm, tools, prompt)

# 5. Buat executor (yang menjalankan loop)
agent_executor = AgentExecutor(
    agent=agent,
    tools=tools,
    verbose=True,   # Tampilkan proses berpikir
    max_iterations=5
)

# 6. Jalankan!
result = agent_executor.invoke({
    "input": "Siapa presiden Indonesia saat ini dan berapa usianya?"
})

print("\n=== JAWABAN FINAL ===")
print(result["output"])

> Entering new AgentExecutor chain...
Thought: Saya perlu mencari informasi tentang presiden Indonesia.
Action: search_web
Action Input: presiden Indonesia 2024
Observation: Judul: Prabowo Subianto...

Thought: Saya sudah punya informasinya. Sekarang saya perlu cari usianya.
Action: search_web
Action Input: usia Prabowo Subianto tahun lahir

... (loop berlanjut) ...

Final Answer: Presiden Indonesia saat ini adalah Prabowo Subianto, 
berusia XX tahun.

# Agent akan: cari info → rangkum → simpan ke file
result = agent_executor.invoke({
    "input": """
    Lakukan tugas berikut langkah demi langkah:
    1. Cari informasi terbaru tentang 'LangChain AI framework'
    2. Buat ringkasan dalam Bahasa Indonesia (200 kata)
    3. Simpan ringkasan tersebut ke file 'langchain_summary.txt'
    4. Konfirmasi bahwa file sudah tersimpan
    """
})

from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain_core.output_parsers import StrOutputParser

llm = ChatOpenAI(model="gpt-4o-mini")

# Chain 1: Buat outline
outline_prompt = ChatPromptTemplate.from_template(
    "Buat outline artikel 5 poin tentang: {topic}"
)

# Chain 2: Tulis artikel berdasarkan outline
article_prompt = ChatPromptTemplate.from_template(
    "Tulis artikel lengkap berdasarkan outline ini:\n{outline}"
)

# Gabungkan dengan LCEL
chain = (
    outline_prompt
    | llm
    | StrOutputParser()
    | {"outline": lambda x: x}
    | article_prompt
    | llm
    | StrOutputParser()
)

# Jalankan!
artikel = chain.invoke({"topic": "AI Agent di industri"})
print(artikel)

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain.agents import create_openai_tools_agent, AgentExecutor
from langchain_community.chat_message_histories import ChatMessageHistory
from langchain_core.runnables.history import RunnableWithMessageHistory

llm = ChatOpenAI(model="gpt-4o-mini")
tools = [search_web, calculate]

# Prompt yang menyertakan chat history
prompt = ChatPromptTemplate.from_messages([
    ("system", "Kamu adalah asisten AI yang membantu. Ingat konteks percakapan."),
    MessagesPlaceholder("chat_history"),  # Tempat history dimasukkan
    ("user", "{input}"),
    MessagesPlaceholder("agent_scratchpad"),
])

agent = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools)

# Simpan history per session
store = {}

def get_session_history(session_id: str):
    if session_id not in store:
        store[session_id] = ChatMessageHistory()
    return store[session_id]

# Bungkus dengan memory
agent_with_memory = RunnableWithMessageHistory(
    executor,
    get_session_history,
    input_messages_key="input",
    history_messages_key="chat_history",
)

# Percakapan dengan memory!
config = {"configurable": {"session_id": "user-123"}}

agent_with_memory.invoke({"input": "Nama saya Budi."}, config=config)
agent_with_memory.invoke({"input": "Siapa nama saya?"}, config=config)
# Agent akan menjawab: "Nama Anda adalah Budi."

research-agent/
├── main.py          # Entry point
├── tools.py         # Semua tools
├── agent.py         # Konfigurasi agent
├── prompts.py       # System prompts
├── .env             # API keys
└── output/          # Hasil laporan

from langchain.tools import tool
from duckduckgo_search import DDGS
import requests
from bs4 import BeautifulSoup
import os
from datetime import datetime

@tool
def search_web(query: str) -> str:
    """Cari artikel/berita dari internet."""
    with DDGS() as ddgs:
        results = list(ddgs.text(query, max_results=5))
    output = ""
    for i, r in enumerate(results, 1):
        output += f"{i}. {r['title']}\n   URL: {r['href']}\n   {r['body']}\n\n"
    return output

@tool
def read_webpage(url: str) -> str:
    """Baca isi lengkap sebuah halaman web."""
    try:
        resp = requests.get(url, timeout=10)
        soup = BeautifulSoup(resp.text, 'html.parser')
        for tag in soup(['script', 'style', 'nav']):
            tag.decompose()
        text = soup.get_text(separator='\n', strip=True)
        return text[:3000]  # Batasi 3000 karakter
    except Exception as e:
        return f"Error: {str(e)}"

@tool
def save_report(topic: str, content: str) -> str:
    """Simpan laporan penelitian ke file."""
    os.makedirs('output', exist_ok=True)
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"output/report_{timestamp}.md"
    with open(filename, 'w', encoding='utf-8') as f:
        f.write(f"# Laporan: {topic}\n\n{content}")
    return f"Laporan disimpan: {filename}"

from langchain_openai import ChatOpenAI
from langchain.agents import create_openai_tools_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from tools import search_web, read_webpage, save_report
from dotenv import load_dotenv

load_dotenv()

# System prompt khusus untuk research
SYSTEM = """Kamu adalah Research Assistant yang handal.
Tugasmu adalah melakukan riset mendalam tentang topik yang diberikan.

Langkah kerja:
1. Cari informasi dari beberapa sumber menggunakan search_web
2. Baca halaman-halaman yang relevan dengan read_webpage
3. Analisis dan rangkum informasi yang ditemukan
4. Buat laporan terstruktur dengan format Markdown
5. Simpan laporan dengan save_report

Selalu gunakan minimal 3 sumber berbeda. Pastikan laporan:
- Memiliki executive summary
- Terstruktur dengan heading yang jelas  
- Menyertakan key findings
- Ditulis dalam Bahasa Indonesia"""

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.3)
tools = [search_web, read_webpage, save_report]

prompt = ChatPromptTemplate.from_messages([
    ("system", SYSTEM),
    ("user", "{input}"),
    MessagesPlaceholder("agent_scratchpad"),
])

agent = create_openai_tools_agent(llm, tools, prompt)
executor = AgentExecutor(
    agent=agent, tools=tools,
    verbose=True, max_iterations=10
)

# Jalankan research!
topic = input("Topik yang ingin diriset: ")
result = executor.invoke({"input": f"Riset mendalam tentang: {topic}"})
print("\n✅ Research selesai! Cek folder 'output' untuk laporan.")