# Minimal agent loop (concept — not framework-specific)
from openai import OpenAI
import json

client = OpenAI()
tools = [search_tool, calculator_tool, email_tool]  # your functions

def run_agent(goal: str) -> str:
    messages = [{"role": "user", "content": goal}]

    while True:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            tools=tool_schemas,        # JSON schemas for each tool
            tool_choice="auto"
        )
        msg = response.choices[0].message

        if msg.tool_calls:
            for tc in msg.tool_calls:
                result = call_tool(tc.function.name, tc.function.arguments)
                messages.append({"role": "tool", "content": result})
        else:
            return msg.content   # agent decided it's done

{
  "type": "function",
  "function": {
    "name": "search_schedules",
    "description": "Search logistics schedules by date range and carrier",
    "parameters": {
      "type": "object",
      "properties": {
        "start_date": { "type": "string", "description": "ISO 8601 date" },
        "end_date":   { "type": "string" },
        "carrier":    { "type": "string", "enum": ["FedEx","UPS","DHL"] }
      },
      "required": ["start_date"]
    }
  }
}

# macOS (homebrew)
brew install ollama

# Or download the app from ollama.ai
# Then start the server:
ollama serve

# Pull a model (downloads ~4-8 GB)
ollama pull llama3.1          # Meta's LLaMA 3.1 8B
ollama pull mistral           # Mistral 7B — fast & capable
ollama pull nomic-embed-text  # For embeddings (768-dim)
ollama pull qwen2.5-coder     # Qwen for code tasks

# Test in terminal
ollama run llama3.1 "Explain RAG in one paragraph"

import requests

def ollama_chat(prompt: str, model="llama3.1") -> str:
    r = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": model, "prompt": prompt, "stream": False}
    )
    return r.json()["response"]

# Or via LangChain (much easier for agents)
from langchain_ollama import ChatOllama

llm = ChatOllama(model="llama3.1", temperature=0)
response = llm.invoke("Summarise this email: ...")

# 1. Install dependencies
pip install langchain langchain-ollama langchain-community
pip install chromadb fastapi uvicorn python-dotenv

# 2. Start Ollama
ollama serve &
ollama pull llama3.1
ollama pull nomic-embed-text

from langchain_ollama import ChatOllama, OllamaEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate
from langchain.tools.retriever import create_retriever_tool

# LLM + embeddings — both local via Ollama
llm = ChatOllama(model="llama3.1", temperature=0)
embeddings = OllamaEmbeddings(model="nomic-embed-text")

# Vector store — persisted to disk
vectorstore = Chroma(
    persist_directory="./chroma_db",
    embedding_function=embeddings
)
retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 4}
)

# Wrap retriever as a tool
rag_tool = create_retriever_tool(
    retriever,
    name="search_schedules",
    description="Searches logistics schedules and past emails"
)

# Build agent
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a logistics scheduling assistant."),
    ("placeholder", "{chat_history}"),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_tool_calling_agent(llm, [rag_tool], prompt)
executor = AgentExecutor(agent=agent, tools=[rag_tool], verbose=True)

result = executor.invoke({"input": "Any conflicts on March 15?"})

pip install openai

from openai import OpenAI

client = OpenAI(api_key="sk-...")   # or use OPENAI_API_KEY env var

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Summarise this email..."}]
)
print(response.choices[0].message.content)

pip install anthropic

import anthropic

client = anthropic.Anthropic(api_key="sk-ant-...")

message = client.messages.create(
    model="claude-3-5-sonnet-20241022",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Analyse this contract..."}]
)
print(message.content[0].text)

pip install google-generativeai

import google.generativeai as genai

genai.configure(api_key="AIza...")

model = genai.GenerativeModel("gemini-2.0-flash")
response = model.generate_content("Explain vector embeddings")
print(response.text)

Goal: "Is there a scheduling conflict on March 15th for DHL?"

Thought: I need to search the schedule database for March 15 DHL entries.
Action: search_schedules({"start_date": "2025-03-15", "carrier": "DHL"})
Observation: Found 3 entries. Two overlap: 14:00 pickup & 14:30 delivery.

Thought: There's a 30-minute conflict. I should flag this for review.
Action: create_conflict_alert({"time": "14:00", "type": "overlap"})
Observation: Alert #4821 created, assigned to scheduler queue.

Thought: Task complete. I have the answer and have taken action.
Final Answer: Yes, conflict found at 14:00-14:30 on March 15 (DHL).
             Alert #4821 created for review.

CONFIDENCE_THRESHOLD = 0.88

async def route_decision(decision: Decision) -> ActionResult:
    if decision.confidence >= CONFIDENCE_THRESHOLD:
        # High confidence — auto-execute
        return await execute_action(decision)
    else:
        # Low confidence — queue for human review
        review_id = await queue_for_review({
            "decision": decision,
            "confidence": decision.confidence,
            "reasoning": decision.reasoning,
            "suggested_action": decision.action
        })
        return ActionResult(status="pending_review", review_id=review_id)

import numpy as np

def cosine_similarity(a: list, b: list) -> float:
    a, b = np.array(a), np.array(b)
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# 1.0 = identical meaning, 0.0 = unrelated, -1.0 = opposite
# Typical RAG threshold: 0.70–0.80 (tune for your domain)

# With OllamaEmbeddings:
from langchain_ollama import OllamaEmbeddings
emb = OllamaEmbeddings(model="nomic-embed-text")

v1 = emb.embed_query("DHL shipment delayed")       # 768 floats
v2 = emb.embed_query("FedEx delivery postponed")    # 768 floats
print(cosine_similarity(v1, v2))  # → ~0.87

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

prompt = ChatPromptTemplate.from_template("""
Answer based on this context:
{context}

Question: {question}
""")

# Pipe syntax: each step feeds the next
rag_chain = (
    {"context": retriever, "question": RunnablePassthrough()}
    | prompt
    | llm
    | StrOutputParser()
)

answer = rag_chain.invoke("What deliveries are due on Friday?")

from langgraph.graph import StateGraph, END
from typing import TypedDict, Annotated
import operator

class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
    confidence: float
    needs_review: bool

def analyse_email(state: AgentState) -> AgentState:
    # Call LLM, update state
    ...

def check_confidence(state: AgentState) -> str:
    return "human_review" if state["confidence"] < 0.88 else "send_reply"

builder = StateGraph(AgentState)
builder.add_node("analyse", analyse_email)
builder.add_node("send_reply", send_email)
builder.add_node("human_review", queue_for_review)

builder.set_entry_point("analyse")
builder.add_conditional_edges("analyse", check_confidence)
builder.add_edge("send_reply", END)
builder.add_edge("human_review", END)

graph = builder.compile()

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

# Load all docs from a folder
documents = SimpleDirectoryReader("./data").load_data()

# Index (embed + store) automatically
index = VectorStoreIndex.from_documents(documents)

# Query with natural language
query_engine = index.as_query_engine()
response = query_engine.query("Summarise all DHL-related emails")

from crewai import Agent, Task, Crew

researcher = Agent(
    role="Logistics Analyst",
    goal="Find schedule conflicts in incoming emails",
    backstory="Expert in supply chain scheduling with 10 years experience",
    tools=[search_schedules, check_calendar],
    llm=llm
)

writer = Agent(
    role="Email Composer",
    goal="Draft professional responses to logistics partners",
    backstory="Specialist in B2B communications",
    llm=llm
)

analyse_task = Task(
    description="Review the email and identify any conflicts",
    agent=researcher, expected_output="Conflict report"
)

reply_task = Task(
    description="Draft a reply addressing identified conflicts",
    agent=writer, expected_output="Email draft"
)

crew = Crew(agents=[researcher, writer], tasks=[analyse_task, reply_task])
result = crew.kickoff()