AI Agent Frameworks

#!/usr/bin/env python3
"""AutoGen - Basic Assistant Agent Example"""

from autogen import AssistantAgent, UserProxyAgent

# ตั้งค่า configuration
config_list = [
    {
        "model": "llama3.2",
        "base_url": "http://localhost:11434/v1",
        "api_key": "ollama"
    }
]

# สร้าง agent
assistant = AssistantAgent(
    name="assistant",
    llm_config={"config_list": config_list},
    system_message="You are a helpful AI assistant who can write Python code."
)

user_proxy = UserProxyAgent(
    name="user_proxy",
    code_execution_config={"work_dir": "coding"},
    llm_config={"config_list": config_list},
    human_input_mode="NEVER"
)

# เริ่มการสนทนา
user_proxy.initiate_chat(
    assistant,
    message="Write a Python function to calculate the factorial of a number. Return only the code."
)

#!/usr/bin/env python3
"""AutoGen - Multi-Agent Research Team"""

from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager

# Configuration
config_list = [
    {
        "model": "llama3.2",
        "base_url": "http://localhost:11434/v1",
        "api_key": "ollama"
    }
]

# Create agents
researcher = AssistantAgent(
    name="researcher",
    llm_config={"config_list": config_list},
    system_message="You are an expert researcher. Focus on finding accurate information."
)

analyst = AssistantAgent(
    name="analyst",
    llm_config={"config_list": config_list},
    system_message="You are an analyst. Summarize and interpret research findings."
)

writer = AssistantAgent(
    name="writer",
    llm_config={"config_list": config_list},
    system_message="You are a technical writer. Write clear, concise documentation."
)

user_proxy = UserProxyAgent(
    name="user_proxy",
    human_input_mode="NEVER",
    code_execution_config=False,
    llm_config={"config_list": config_list}
)

# Create group chat
groupchat = GroupChat(
    agents=[researcher, analyst, writer, user_proxy],
    messages=[],
    max_round=6
)

manager = GroupChatManager(
    groupchat=groupchat,
    llm_config={"config_list": config_list}
)

# Initiate conversation
user_proxy.initiate_chat(
    manager,
    message="Research and document the latest trends in AI Agent frameworks for 2025."
)

#!/usr/bin/env python3
"""LangGraph - Simple Chain Example"""

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

# Initialize LLM (using Ollama)
llm = ChatOpenAI(
    model="llama3.2",
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

# Create prompt template
prompt = ChatPromptTemplate.from_template(
    "Explain {topic} in simple terms suitable for a beginner. Keep it under 100 words."
)

# Create output parser
parser = StrOutputParser()

# Create chain
chain = prompt | llm | parser

# Run chain
result = chain.invoke({"topic": "AI Agent Frameworks"})
print(result)

#!/usr/bin/env python3
"""LangGraph - State Machine with Memory"""

from typing import TypedDict, Annotated
from langgraph.graph import Graph, END
from langchain_openai import ChatOpenAI
import operator

# Initialize LLM
llm = ChatOpenAI(
    model="llama3.2",
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

# Define state
class AgentState(TypedDict):
    task: str
    result: str
    feedback: list

# Define nodes
def researcher_node(state: AgentState):
    """Researchnode"""
    response = llm.invoke(
        f"Research the following topic and return key points: {state['task']}"
    )
    return {"result": response.content, "feedback": []}

def analyst_node(state: AgentState):
    """Analyze results"""
    response = llm.invoke(
        f"Analyze and summarize: {state['result']}"
    )
    return {"result": response.content}

def writer_node(state: AgentState):
    """Write final document"""
    response = llm.invoke(
        f"Write a technical document based on: {state['result']}"
    )
    return {"result": response.content, "feedback": state.get("feedback", [])}

# Build graph
workflow = Graph()
workflow.add_node("researcher", researcher_node)
workflow.add_node("analyst", analyst_node)
workflow.add_node("writer", writer_node)

workflow.add_edge("researcher", "analyst")
workflow.add_edge("analyst", "writer")
workflow.add_edge("writer", END)

workflow.set_entry_point("researcher")

# Compile and run
app = workflow.compile()

# Run
result = app.invoke({"task": "AI Agent Frameworks 2025"})
print(result["result"])

#!/usr/bin/env python3
"""CrewAI - Simple Task Assignment"""

from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI

# Initialize LLM with Ollama
llm = ChatOpenAI(
    model="llama3.2",
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

# Create agent: Researcher
researcher = Agent(
    role='Researcher',
    goal='Find accurate and relevant information',
    backstory="""You are an expert researcher with 10 years of experience.
    You specialize in finding the latest information on AI technologies.""",
    llm=llm,
    verbose=True
)

# Create agent: Writer
writer = Agent(
    role='Writer',
    goal='Write clear, engaging technical content',
    backstory="""You are a technical writer who specializes in AI.
    You can explain complex topics in simple terms.""",
    llm=llm,
    verbose=True
)

# Create task
research_task = Task(
    description="""Research the latest AI Agent frameworks in 2025.
    Include: AutoGen, LangGraph, CrewAI, and their key features.""",
    expected_output="A bulleted list of key features for each framework.",
    agent=researcher
)

write_task = Task(
    description="""Write a technical article based on the research.
    Include: Introduction, comparison table, and recommendations.""",
    expected_output="A complete technical article in Markdown format.",
    agent=writer
)

# Create crew
crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    process=Process.sequential,
    verbose=True
)

# Run crew
result = crew.kickoff()
print(result)

#!/usr/bin/env python3
"""CrewAI - Hierarchical Process Example"""

from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI

# Initialize LLM with Ollama
llm = ChatOpenAI(
    model="llama3.2",
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

# Create Manager Agent (for hierarchical process)
project_manager = Agent(
    role='Project Manager',
    goal='Coordinate the team and ensure timely delivery',
    backstory="""You are an experienced project manager who specializes
    in AI projects. You coordinate different specialists and ensure
    all tasks are completed on time.""",
    llm=llm,
    verbose=True
)

# Create specialist agents
data_scientist = Agent(
    role='Data Scientist',
    goal='Analyze data and build models',
    backstory="""You are an expert data scientist with strong Python skills.
    You specialize in machine learning and data analysis.""",
    llm=llm
)

developer = Agent(
    role='Developer',
    goal='Write clean, efficient code',
    backstory="""You are a senior developer with experience in AI applications.
    You write production-ready code following best practices.""",
    llm=llm
)

documenter = Agent(
    role='Documenter',
    goal='Create comprehensive documentation',
    backstory="""You are a technical writer who creates clear,
    detailed documentation for AI projects.""",
    llm=llm
)

# Create tasks with dependencies
analyze_data_task = Task(
    description="""Analyze the latest AI Agent framework trends from 2024-2025.
    Create a data summary showing GitHub stars, release dates, and key features.""",
    expected_output="A detailed data analysis report in JSON format.",
    agent=data_scientist
)

develop_prototype_task = Task(
    description="""Create a prototype AI agent using any framework.
    The agent should be able to answer questions about its framework.""",
    expected_output="Working Python code with documentation.",
    agent=developer
)

write_docs_task = Task(
    description="""Create comprehensive documentation for the prototype.
    Include setup instructions, usage examples, and troubleshooting guide.""",
    expected_output="Complete documentation in Markdown format.",
    agent=documenter
)

# Create crew with hierarchical process
crew = Crew(
    agents=[project_manager, data_scientist, developer, documenter],
    tasks=[analyze_data_task, develop_prototype_task, write_docs_task],
    process=Process.hierarchical,
    manager_llm=llm,
    verbose=True
)

# Run crew
result = crew.kickoff()
print(result)

from autogen import AssistantAgent

config_list = [
    {
        "model": "llama3.2",
        "base_url": "http://localhost:11434/v1",
        "api_key": "ollama"
    }
]

assistant = AssistantAgent(
    name="assistant",
    llm_config={"config_list": config_list}
)

from langchain_openai import ChatOpenAI
from langchain_ollama import ChatOllama

# Option 1: Using langchain-openai (compatible)
llm = ChatOpenAI(
    model="llama3.2",
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

# Option 2: Using langchain-ollama (native integration)
llm = ChatOllama(
    model="llama3.2",
    base_url="http://localhost:11434"
)

from crewai import Agent
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    model="llama3.2",
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

agent = Agent(
    role='Assistant',
    llm=llm
)

#!/usr/bin/env python3
"""Test Ollama Connection"""

import ollama

# Test 1: Check if Ollama is running
try:
    models = ollama.list()
    print("Connected to Ollama!")
    print("Available models:", [m['name'] for m in models['models']])
except Exception as e:
    print(f"Error connecting to Ollama: {e}")

# Test 2: Simple chat
try:
    response = ollama.chat(
        model='llama3.2',
        messages=[{'role': 'user', 'content': 'Hello!'}]
    )
    print(f"Response: {response['message']['content']}")
except Exception as e:
    print(f"Error in chat: {e}")