Use langchain + HF model for tool orchestration

Adding a single tool is helpful — but what if you want your assistant to:

• Decide which tool to use

• Call multiple tools in one conversation

• Combine LLM + tools automatically

👉 This is where LangChain comes in.

---

✅ What is LangChain?

LangChain is an open-source framework for:

• Building LLM “agents” that can plan actions.

• Managing tool use, memory, and context automatically.

• Integrating your own models (e.g., Hugging Face) + APIs + functions.

---

✅ Why Use LangChain?

✔️ Automates tool routing — no manual “if weather” checks. ✔️ Chains multiple steps: retrieve info ➜ call a tool ➜ generate final answer. ✔️ Supports structured output (JSON) if you need it. ✔️ Plays nicely with Hugging Face local models.

---

✅ How It Works

1️⃣ You define:

• An LLM (can be your fine-tuned HF model)

• A set of tools (Python functions, APIs, or search)

• An agent that decides which tool to call, based on the user prompt

2️⃣ LangChain wraps this logic into a reusable pipeline.

---

✅ Basic Setup Example

---

1️⃣ Install LangChain

pip install langchain

---

2️⃣ Define Your HF LLM

from langchain import HuggingFacePipeline
from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM

model_name = "YOUR_USERNAME/YOUR_MODEL"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)

pipe = pipeline("text-generation", model=model, tokenizer=tokenizer, max_length=512)

llm = HuggingFacePipeline(pipeline=pipe)

---

3️⃣ Define Tools

from langchain.tools import Tool

def get_weather(city: str) -> str:
    return f"(Demo) The weather in {city} is 25°C and sunny."

def calculate(expression: str) -> str:
    try:
        return f"Result: {eval(expression)}"
    except:
        return "Sorry, I couldn’t compute that."

tools = [
    Tool(
        name="WeatherAPI",
        func=get_weather,
        description="Get weather for a given city."
    ),
    Tool(
        name="Calculator",
        func=calculate,
        description="Evaluate a math expression."
    ),
]

---

4️⃣ Create an Agent

from langchain.agents import initialize_agent, AgentType

agent = initialize_agent(
    tools,
    llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,  # REACT = Reason + Act
    verbose=True
)

---

5️⃣ Run It

response = agent.run("What is the weather in Paris and what is 15% of 400?")
print("Assistant:", response)

✅ LangChain’s agent:

• Parses the question

• Figures out it needs both tools

• Calls each function

• Generates a final, combined answer

---

✅ How This Works Behind the Scenes

LangChain’s ReAct agent uses your LLM to:

• Read the user query

• “Think” which tool to run

• Call the tool’s Python function

• Feed the result back to the model

• Compose the final reply

---

✅ When to Use LangChain

Use Case	Why
Multiple tools	Weather, math, search, file lookups
Structured tasks	Database calls, function calls
Dynamic decisions	User asks for something unexpected
Reusable agent logic	Combine HF model + plugins in one pipeline

---

✅ Tips for HF + LangChain

✔️ Works best with instruction-following models (e.g., Llama‑2‑Chat, Mistral‑Instruct). ✔️ Keep your tools simple and safe (sanitize input). ✔️ Use verbose mode to debug agent reasoning steps. ✔️ If you have heavy tasks, run tools outside the LLM — only pass final output back.

---

🗝️ Key Takeaway

LangChain + HF = your assistant goes from static text to interactive agent — capable of calling real tools, following user instructions, and handling tasks that a static LLM never could.

---

➡️ Next: Learn how to add guardrails, handle errors gracefully, and keep your agent secure!