Categories
Python

FastAPI Time Function

from fastapi import FastAPI
from pydantic import BaseModel
from datetime import datetime
import pytz
import uvicorn
import threading

class TimeRequest(BaseModel):
    location: str

class MyTime:
    def __init__(self, location: str, host: str = None, port: int = None, route: str = "/time"):
        self.location = location
        self.route = route
        self.time_str = self._get_time_by_location()
        print(f"[MyTime] {self.location}: {self.time_str}")

        if host and port:
            threading.Thread(
                target=self._start_fastapi_server,
                args=(host, port, route),
                daemon=True
            ).start()

    def _get_time_by_location(self, loc: str = None) -> str:
        loc = loc or self.location
        try:
            timezone = pytz.timezone(loc)
            local_time = datetime.now(timezone)
            return local_time.strftime('%Y-%m-%d %H:%M:%S')
        except pytz.UnknownTimeZoneError:
            return f"Unknown timezone: {loc}"

    def _start_fastapi_server(self, host, port, route):
        app = FastAPI()

        @app.post(route)
        async def get_time(req: TimeRequest):
            return {"time": self._get_time_by_location(req.location)}

        uvicorn.run(app, host=host, port=port, log_level="info")

# Example usage
if __name__ == "__main__":
    MyTime("Asia/Kolkata", host="0.0.0.0", port=7860, route="/time")

curl -X POST http://localhost:7860/time \
     -H "Content-Type: application/json" \
     -d '{"location": "Europe/London"}'
Categories
Praison AI

Llama 4 Agents

export GROQ_API_KEY=xxxxxxx
export BRAVE_API_KEY=xxxxxxx
pip install -U "praisonaiagents[llm,mcp]" gradio
from praisonaiagents import Agent, Agents, MCP
import os

brave_api_key = os.getenv("BRAVE_API_KEY")

# Travel Research Agent
research_agent = Agent(
    instructions="Research about travel destinations, attractions, local customs, and travel requirements",
    llm="groq/meta-llama/llama-4-scout-17b-16e-instruct",
    tools=MCP("npx -y @modelcontextprotocol/server-brave-search", env={"BRAVE_API_KEY": brave_api_key})
)

# Flight Booking Agent
flight_agent = Agent(
    instructions="Search for available flights, compare prices, and recommend optimal flight choices",
    llm="groq/meta-llama/llama-4-scout-17b-16e-instruct",
    tools=MCP("npx -y @modelcontextprotocol/server-brave-search", env={"BRAVE_API_KEY": brave_api_key})
)

# Accommodation Agent
hotel_agent = Agent(
    instructions="Research hotels and accommodation based on budget and preferences",
    llm="groq/meta-llama/llama-4-scout-17b-16e-instruct",
    tools=MCP("npx -y @modelcontextprotocol/server-brave-search", env={"BRAVE_API_KEY": brave_api_key})
)

# Itinerary Planning Agent
planning_agent = Agent(
    instructions="Design detailed day-by-day travel plans incorporating activities, transport, and rest time",
    llm="groq/meta-llama/llama-4-scout-17b-16e-instruct",
    tools=MCP("npx -y @modelcontextprotocol/server-brave-search", env={"BRAVE_API_KEY": brave_api_key})
)

# Example usage - research travel destinations
destination = "London, UK"
dates = "August 15-22, 2025"
budget = "Mid-range (£1000-£1500)"
preferences = "Historical sites, local cuisine, avoiding crowded tourist traps"
travel_query = f"What are the best attractions to visit in {destination} during {dates} on a budget of {budget} with preferences of {preferences}?"
agents = Agents(agents=[research_agent, flight_agent, hotel_agent, planning_agent])

result = agents.start(travel_query)
print(f"\n=== DESTINATION RESEARCH: {destination} ===\n")
print(result)
from praisonaiagents import Agent, Agents, MCP
import os
from rich import print
import gradio as gr

brave_api_key = os.getenv("BRAVE_API_KEY")

# Travel Research Agent
research_agent = Agent(
    instructions="Research about travel destinations, attractions, local customs, and travel requirements",
    llm="groq/meta-llama/llama-4-scout-17b-16e-instruct",
    tools=MCP("npx -y @modelcontextprotocol/server-brave-search", env={"BRAVE_API_KEY": brave_api_key})
)

# Flight Booking Agent
flight_agent = Agent(
    instructions="Search for available flights, compare prices, and recommend optimal flight choices",
    llm="groq/meta-llama/llama-4-scout-17b-16e-instruct",
    tools=MCP("npx -y @modelcontextprotocol/server-brave-search", env={"BRAVE_API_KEY": brave_api_key})
)

# Accommodation Agent
hotel_agent = Agent(
    instructions="Research hotels and accommodation based on budget and preferences",
    llm="groq/meta-llama/llama-4-scout-17b-16e-instruct",
    tools=MCP("npx -y @modelcontextprotocol/server-brave-search", env={"BRAVE_API_KEY": brave_api_key})
)

# Itinerary Planning Agent
itinerary_agent = Agent(
    instructions="Design detailed day-by-day travel plans incorporating activities, transport, and rest time",
    llm="groq/meta-llama/llama-4-scout-17b-16e-instruct",
    tools=MCP("npx -y @modelcontextprotocol/server-brave-search", env={"BRAVE_API_KEY": brave_api_key})
)

def generate_travel_plan(destination, dates, budget, preferences):
    """Generate a travel plan using the AI agents"""
    
    # Create the travel query
    travel_query = f"""Create a comprehensive travel plan for {destination} during {dates}.
    Budget: {budget}
    Preferences: {preferences}
    
    Include:
    1. Information about the destination
    2. Flight recommendations
    3. Hotel options
    4. A day-by-day itinerary
    """
    
    # Initialize the agents team
    agents = Agents(agents=[research_agent, flight_agent, hotel_agent, itinerary_agent])
    
    try:
        # Generate the travel plan
        result = agents.start(travel_query)
        
        # Format the output
        formatted_result = f"""
=== TRAVEL PLAN: {destination} ===

Dates: {dates}
Budget: {budget}
Preferences: {preferences}

{result}
"""
        
        return formatted_result
    except Exception as e:
        return f"Error generating travel plan: {str(e)}"

# Create the Gradio interface
with gr.Blocks(title="AI Travel Agency", theme="soft") as demo:
    gr.Markdown("# 🌍 AI Travel Agency")
    gr.Markdown("Plan your perfect trip with our AI agents")
    
    with gr.Row():
        with gr.Column(scale=1):
            destination = gr.Textbox(label="Destination", placeholder="London, UK", value="London, UK")
            dates = gr.Textbox(label="Travel Dates", placeholder="August 15-22, 2024", value="August 15-22, 2024")
            budget = gr.Textbox(label="Budget", placeholder="Mid-range (£1000-£1500)", value="Mid-range (£1000-£1500)")
            preferences = gr.Textbox(
                label="Travel Preferences", 
                placeholder="Historical sites, local cuisine, avoiding crowded tourist traps",
                value="Historical sites, local cuisine, avoiding crowded tourist traps"
            )
            submit_btn = gr.Button("Generate Travel Plan 🚀", variant="primary")
        
        with gr.Column(scale=2):
            output = gr.Markdown(label="Your Travel Plan")
    
    submit_btn.click(
        generate_travel_plan,
        inputs=[destination, dates, budget, preferences],
        outputs=output
    )
    
    gr.Markdown("### How to use")
    gr.Markdown("""
    1. Enter your destination
    2. Specify your travel dates
    3. Indicate your budget range
    4. Share your travel preferences
    5. Click 'Generate Travel Plan'
    
    *Note: Generation may take a minute or two as our AI agents research your perfect trip.*
    """)

# Run the CLI version when script is run directly
if __name__ == "__main__":
    # Launch the Gradio interface
    demo.launch()
    
    # Example CLI usage (commented out when using Gradio)
    """
    destination = "London, UK"
    dates = "August 15-22, 2025"
    budget = "Mid-range (£1000-£1500)"
    preferences = "Historical sites, local cuisine, avoiding crowded tourist traps"
    
    travel_query = f"What are the best attractions to visit in {destination} during {dates} on a budget of {budget} with preferences of {preferences}?"
    agents = Agents(agents=[planning_agent, flight_agent, hotel_agent, planning_agent])
    result = agents.start(travel_query)
    print(f"\n=== DESTINATION RESEARCH: {destination} ===\n")
    print(result)
    """
Categories
Tools

MCP Server SSE URL

Model context Protocol server SSE URL

from mcp.server.fastmcp import FastMCP
import yfinance as yf
from starlette.applications import Starlette
from starlette.routing import Mount
import uvicorn
import logging

# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Create FastMCP server
mcp = FastMCP("Stock Price Server")

@mcp.tool()
def get_stock_price(ticker: str) -> str:
    """Get the current stock price for a given ticker symbol"""
    try:
        logger.info(f"Fetching stock price for ticker: {ticker}")
        stock = yf.Ticker(ticker)
        price = str(stock.history(period="1d")['Close'].iloc[-1])
        logger.info(f"Price for {ticker}: {price}")
        return price
    except Exception as e:
        logger.error(f"Error getting stock price for {ticker}: {str(e)}")
        return f"Error getting stock price: {str(e)}"

# Create a Starlette application with the SSE endpoint
app = Starlette(routes=[
    # Mount the SSE app directly at the root
    Mount("/", app=mcp.sse_app()),
])

if __name__ == "__main__":
    logger.info("Starting Uvicorn server...")
    uvicorn.run(app, host="127.0.0.1", port=8000)

Config

{
  "mcpServers": {
    "stock-price": {
      "serverUrl": "http://127.0.0.1:8000/sse"
    }
  }
}
Categories
Tools

MCP Beginners Guide

pip install "mcp[cli]" yfinance
import yfinance as yf
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("stock_prices")

@mcp.tool()
async def get_stock_price(ticker: str) -> str:
    """Get the current stock price for a given ticker symbol.
    
    Args:
        ticker: Stock ticker symbol (e.g., AAPL, MSFT, GOOG)
        
    Returns:
        Current stock price as a string
    """
    try:
        stock = yf.Ticker(ticker)
        info = stock.info
        current_price = info.get('currentPrice') or info.get('regularMarketPrice')
        if not current_price:
            return f"Could not retrieve price for {ticker}"
        return f"${current_price:.2f}"
        
    except Exception as e:
        return f"Error: {str(e)}"

if __name__ == "__main__":
    mcp.run(transport='stdio')
{
  "mcpServers": {
    "stock_prices": {
      "command": "/Users/praison/miniconda3/envs/mcp/bin/python",
      "args": [
        "/Users/praison/stockprice/app.py"
      ]
  }
}

With Other Providers

{
  "mcpServers": {
    "stock_prices": {
      "command": "/Users/praison/miniconda3/envs/mcp/bin/python",
      "args": [
        "/Users/praison/stockprice/app.py"
      ]
    },
    "neon": {
      "command": "npx",
      "args": [
        "-y",
        "@smithery/cli@latest",
        "run",
        "neon",
        "--config",
        "\"{\\\"apiKey\\\":\\\"YOUR_NEON_API_KEY\\\"}\""
      ]
    }
  }
}
Categories
OpenAI

OpenAI Response API Basics

pip install -U openai geopy gradio rich
export OPENAI_API_KEY=xxxxxxxx

Basic

from openai import OpenAI
client = OpenAI()

response = client.responses.create(
    model="gpt-4o",
    input="Write a one-sentence bedtime story about a unicorn."
)

print(response.output_text)

UI

import gradio as gr
from openai import OpenAI

client = OpenAI()

def ask_ai(question):
    response = client.responses.create(
        model="gpt-4o",
        input=question
    )
    return response.output_text

demo = gr.Interface(
    fn=ask_ai,
    inputs="text",
    outputs="text",
    title="AI Assistant"
)

if __name__ == "__main__":
    demo.launch()

Tools

from openai import OpenAI
client = OpenAI()

response = client.responses.create(
    model="gpt-4o",
    tools=[{"type": "web_search_preview"}],
    input="Give me two AI news story from today in 2 sentence."
)

print(response.output_text)

RAG

from openai import OpenAI
from rich import print
client = OpenAI()

response = client.responses.create(
    model="gpt-4o-mini",
    input="Tell me about GraphRAG",
    tools=[{
        "type": "file_search",
        "vector_store_ids": ["vs_67d08c2b03asdf"]
    }]
)
print(response)

Custom Tools

from openai import OpenAI
import requests
import json
from rich import print
from geopy.geocoders import Nominatim

client = OpenAI()

# 1. Create Custom Tool
def get_weather(location):
    geolocator = Nominatim(user_agent="weather_app")
    location_data = geolocator.geocode(location)
    latitude, longitude = location_data.latitude, location_data.longitude if location_data else (0, 0)
    response = requests.get(f"https://api.open-meteo.com/v1/forecast?latitude={latitude}&longitude={longitude}&current=temperature_2m,wind_speed_10m&hourly=temperature_2m,relative_humidity_2m,wind_speed_10m")
    data = response.json()
    return data['current']['temperature_2m']

# 2. Create Custom Tool Definition
tools = [{
    "type": "function",
    "name": "get_weather",
    "description": "Get current temperature for a given location.",
    "parameters": {
        "type": "object",
        "properties": {
            "location": {
                "type": "string",
                "description": "City and country e.g. Bogotá, Colombia"
            }
        },
        "required": [
            "location"
        ],
        "additionalProperties": False
    }
}]

# 3. Ask Question to the model
input_messages = [{"role": "user", "content": "What is the weather like in Paris today?"}]
response = client.responses.create(
    model="gpt-4o",
    input=input_messages,
    tools=tools
)
print(f"Response: {response.output}")

# 4. Parse the model's response & Run the Tool
tool_call = response.output[0]
args = json.loads(tool_call.arguments)
result = get_weather(args["location"])
print(f"Result: {result}")

# 5. Append the result to the input messages
input_messages.append(tool_call)  
input_messages.append({           
    "type": "function_call_output",
    "call_id": tool_call.call_id,
    "output": str(result)
})

# 6. Ask the model again with original question and the response from the tool
response_2 = client.responses.create(
    model="gpt-4o",
    input=input_messages,
    tools=tools,
)
print(f"Response 2: {response_2.output_text}")

Stream

from openai import OpenAI
client = OpenAI()

stream = client.responses.create(
    model="gpt-4o-mini",
    input=[
        {
            "role": "user",
            "content": "Write a 1000 words bedtime story about a unicorn.",
        },
    ],
    stream=True,
)

for event in stream:
    if hasattr(event, 'delta'):
        print(event.delta, end="")
    elif hasattr(event, 'text') and event.type == 'response.output_text.done':
        pass

LM Studio Upcoming update

from openai import OpenAI
client = OpenAI(base_url="http://localhost:1234/v1", api_key="fake-key")

response = client.responses.create(
    model="gemma3",
    input="Write a one-sentence bedtime story about a unicorn."
)

print(response)
Categories
Praison AI

Elon Musk Mervin Praison

Categories
Ollama

OpenAI Agents SDK Ollama

Installation

Download Ollama from https://ollama.com 

pip install -U openai-agents chainlit duckduckgo-search
ollama pull llama3.2

Single Agent

from agents import Agent, Runner, OpenAIChatCompletionsModel, AsyncOpenAI

model = OpenAIChatCompletionsModel( 
    model="llama3.2",
    openai_client=AsyncOpenAI(base_url="http://localhost:11434/v1")
)

agent = Agent(name="Assistant",
              instructions="You are a helpful assistant",
              model=model)

result = Runner.run_sync(agent, "Create a meal plan for a week.")
print(result.final_output)
python app.py

Multi Agents

from duckduckgo_search import DDGS
from agents import Agent, Runner, AsyncOpenAI, OpenAIChatCompletionsModel, function_tool
from datetime import datetime

current_date = datetime.now().strftime("%Y-%m")

model = OpenAIChatCompletionsModel(
    model="llama3.2",
    openai_client=AsyncOpenAI(base_url="http://localhost:11434/v1")
)

# 1. Create Internet Search Tool

@function_tool
def get_news_articles(topic):
    print(f"Running DuckDuckGo news search for {topic}...")
    
    # DuckDuckGo search
    ddg_api = DDGS()
    results = ddg_api.text(f"{topic} {current_date}", max_results=5)
    if results:
        news_results = "\n\n".join([f"Title: {result['title']}\nURL: {result['href']}\nDescription: {result['body']}" for result in results])
        print(news_results)
        return news_results
    else:
        return f"Could not find news results for {topic}."
    
# 2. Create AI Agents

# News Agent to fetch news
news_agent = Agent(
    name="News Assistant",
    instructions="You provide the latest news articles for a given topic using DuckDuckGo search.",
    tools=[get_news_articles],
    model=model
)

# Editor Agent to edit news
editor_agent = Agent(
    name="Editor Assistant",
    instructions="Rewrite and give me as news article ready for publishing. Each News story in separate section.",
    model=model
)

# 3. Create workflow

def run_news_workflow(topic):
    print("Running news Agent workflow...")
    
    # Step 1: Fetch news
    news_response = Runner.run_sync(
        news_agent,
        f"Get me the news about {topic} on {current_date}"
    )
    
    # Access the content from RunResult object
    raw_news = news_response.final_output
    
    # Step 2: Pass news to editor for final review
    edited_news_response = Runner.run_sync(
        editor_agent,
        raw_news
    )
    
    # Access the content from RunResult object
    edited_news = edited_news_response.final_output
    
    print("Final news article:")
    print(edited_news)
    
    return edited_news

# Example of running the news workflow for a given topic
print(run_news_workflow("AI"))

UI

import chainlit as cl
from news import run_news_workflow

@cl.on_message
async def main(message: cl.Message):
    """
    Main function to handle user messages and run the news workflow.
    """
    # Get the topic from the user message
    topic = message.content
    
    # Send a thinking message
    await cl.Message(
        content=f"Searching for news about '{topic}'...",
        author="News Bot"
    ).send()
    
    try:
        # Run the news workflow
        news_content = run_news_workflow(topic)
        
        # Send the result back to the user
        await cl.Message(
            content=news_content,
            author="News Bot"
        ).send()
    except Exception as e:
        # Handle any errors
        await cl.Message(
            content=f"Error fetching news: {str(e)}",
            author="News Bot"
        ).send()

@cl.on_chat_start
async def start():
    """
    Function that runs when a new chat session starts.
    """
    # Send a welcome message
    await cl.Message(
        content="Welcome to the News Assistant! What topic would you like to get news about?",
        author="News Bot"
    ).send() 
chainlit run ui.py
Categories
Ollama

Gemma 3 Create Agents

ollama pull gemma3
pip install ollama chainlit "praisonaiagents[llm]"

Ollama code

import ollama

response = ollama.chat(
    model='gemma3',
    messages=[
        {
        'role': 'user',
        'content': 'Give me a meal plan for today',
        },
    ],
)

print(response['message']['content'])
python app.py

UI

ui.py file

import ollama
import chainlit as cl

@cl.on_message
async def main(message: cl.Message):
    response = ollama.chat(
        model='gemma3',
        messages=[
            {
            'role': 'user',
            'content': message.content,
            },
        ],
    )
    
    await cl.Message(content=response['message']['content']).send()

@cl.on_chat_start
async def start():
    await cl.Message(content="Hello! I'm Gemma3. How can I help you today?").send()
chainlit run ui.py

Single Agent

from praisonaiagents import Agent

agent = Agent( instructions="You are a helpful assistant",llm="ollama/gemma3")

agent.start("Why sky is Blue?")

python app.py

Multi Agents

from praisonaiagents import Agent, PraisonAIAgents
from praisonaiagents.tools import internet_search

agent1 = Agent(instructions="Write a linkedIn post", tools=[internet_search], llm="ollama/gemma3")
agent2 = Agent(instructions="Write a tweet based on the linkedIn post", llm="ollama/gemma3")

agents = PraisonAIAgents(agents=[agent1, agent2])

agents.start("Write about donald trump 2025 election")
python app.py
Categories
OpenAI

OpenAI Responses API Basics

pip install openai
export OPENAI_API_KEY=xxxxxxxxxxxxx

Responses API

from openai import OpenAI
from rich import print
client = OpenAI()

response = client.responses.create(
    model="gpt-4o",
    input="Write a meal plan for a week."
)

print(response.output_text)

Chatbot 

pip install gradio
from openai import OpenAI
from rich import print
import gradio as gr

client = OpenAI()

def generate_response(prompt):
    response = client.responses.create(
        model="gpt-4o",
        input=prompt
    )
    return response.output_text

# Create Gradio interface
demo = gr.Interface(
    fn=generate_response,
    inputs=gr.Textbox(placeholder="Enter your prompt here...", label="Prompt", value="Write a meal plan for a week."),
    outputs=gr.Textbox(label="Response"),
    title="OpenAI GPT-4o",
    description="Enter a prompt to get a response from GPT-4o"
)

if __name__ == "__main__":
    demo.launch()

Web Search

from openai import OpenAI
client = OpenAI()

response = client.responses.create(
    model="gpt-4o",
    tools=[{"type": "web_search_preview"}],
    input="Tell me about Mervin Praison"
)

print(response.output_text)

File Search

from openai import OpenAI
from rich import print
client = OpenAI()

response = client.responses.create(
    model="gpt-4o-mini",
    input="Tell me about GraphRAG",
    tools=[{
        "type": "file_search",
        "vector_store_ids": ["vs_67d08c2b03ac8191baff7fbbfcc7ffd2"]
    }]
)
print(response)

Computer Use

from openai import OpenAI
client = OpenAI()

response = client.responses.create(
    model="computer-use-preview",
    tools=[{
        "type": "computer_use_preview",
        "display_width": 1024,
        "display_height": 768,
        "environment": "browser" # other possible values: "mac", "windows", "ubuntu"
    }],
    input=[
        {
            "role": "user",
            "content": "Check the latest OpenAI news on bing.com."
        }
    ],
    truncation="auto"
)

print(response.output)

Tool

from agents import Agent, ModelSettings, function_tool, Runner

def get_weather(city: str) -> str:
    return f"The weather in {city} is sunny and 34 degree celsius"

agent = Agent(
    name="Haiku agent",
    instructions="Always respond in haiku form",
    model="gpt-4o-mini",
    tools=[function_tool(get_weather)],
)

result = Runner.run_sync(agent, "What's the weather in Tokyo?")
print(result.final_output)

Agents SDK

pip install openai-agents
from agents import Agent, Runner

agent = Agent(name="Assistant", instructions="You are a helpful assistant")

result = Runner.run_sync(agent, "Create a meal plan for a week.")
print(result.final_output)
Categories
Tools

MCP Browser Logs Config

{
  "mcpServers": {
    "browser-tools": {
      "command": "npx",
      "args": [
        "-y",
        "@agentdeskai/browser-tools-mcp@1.0.11"
      ]
    }
  }
}