initilize with ok pydantic ai

.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

.python-version

@@ -0,0 +1 @@
+3.13

README.md

@@ -10,3 +10,40 @@ pinned: false
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# Marvin AI 对话演示
+
+使用 Marvin AI 框架创建三个 AI 智能体进行对话：Alice（教练）、Bob（有问题的人）、Critic（评价者）。
+
+## 安装
+
+```bash
+uv add marvin
+```
+
+## 设置 API 密钥
+
+```bash
+export OPENAI_API_KEY="你的-openai-api-密钥"
+```
+
+获取 API 密钥：访问 [OpenAI 官网](https://platform.openai.com/) → 注册/登录 → API 部分 → 生成新密钥
+
+## 运行
+
+```bash
+uv run marvin_test.py
+```
+
+## 工作流程
+
+1. Alice 和 Bob 进行 3 轮对话
+2. 每轮后按回车继续
+3. Critic 评价对话质量
+4. 结果保存到 `score.json`
+
+## 常见问题
+
+- **API 密钥错误**：检查 `OPENAI_API_KEY` 是否正确设置
+- **模块未找到**：运行 `uv add marvin`
+- **速率限制**：等待片刻后重试

alice_agent.py

@@ -0,0 +1 @@
+ 

alice_gradio.py

@@ -0,0 +1,11 @@
+import gradio as gr
+from marvin import Agent
+
+bot = Agent("Jokester", instructions="Tell witty one-liners.")
+
+async def talk(msg, history):
+    return await bot(msg)            # Marvin v2 → awaitable
+
+demo = gr.ChatInterface(talk, title="Jokester")
+demo.queue()                         # initialise the queue explicitly
+demo.launch()

convo-pai.py

@@ -0,0 +1,115 @@
+from pydantic_ai import Agent
+import json
+from typing import Dict, Any
+
+# Define the three agents using pydantic-ai
+alice = Agent(
+    'openai:gpt-4o',
+    system_prompt="You are a coach, speak like coach, start with question if no convo history; you speak very concisely, one sentence at a time"
+)
+
+bob = Agent(
+    'openai:gpt-4o', 
+    system_prompt="You have a problem with your kids. and speak very concisely, one sentence at a time"
+)
+
+critic = Agent(
+    'openai:gpt-4o',
+    system_prompt=(
+        "Score the dialogue on insight (0-10) and civility (0-10); "
+        "return JSON with fields 'insight', 'civility', 'comment'."
+    )
+)
+
+def format_conversation_history(conversation):
+    """Format conversation history for context"""
+    if not conversation:
+        return "No previous conversation."
+    return "\n".join([f"{speaker}: {message}" for speaker, message in conversation])
+
+# Simple ping-pong conversation loop
+conversation = []
+print("Starting conversation between Alice (coach) and Bob (person with problems)...\n")
+
+for round_num in range(3):
+    print(f"=== Round {round_num + 1} ===")
+    
+    # Alice speaks (coach asking questions/helping)
+    history_context = format_conversation_history(conversation)
+    alice_prompt = f"Your want to ask bob questions, help bob. Conversation history:\n{history_context}"
+    
+    alice_result = alice.run_sync(alice_prompt)
+    alice_msg = alice_result.output
+    conversation.append(("Alice", alice_msg))
+    print(f"Alice: {alice_msg}")
+
+    # Bob responds with his problem
+    history_context = format_conversation_history(conversation)
+    bob_prompt = f"Respond to Alice with your problem. Conversation history:\n{history_context}"
+    
+    bob_result = bob.run_sync(bob_prompt)
+    bob_msg = bob_result.output
+    conversation.append(("Bob", bob_msg))
+    print(f"Bob: {bob_msg}")
+    
+    print()
+    input("Press Enter to continue...")
+
+# Convert conversation to a string format for the critic
+conversation_text = "\n\n".join([f"{speaker}: {message}" for speaker, message in conversation])
+
+print("\n=== Critic Evaluation ===")
+print("Getting evaluation from critic...")
+
+# Third agent evaluates the conversation
+critic_prompt = f"Please evaluate this conversation:\n\n{conversation_text}"
+
+try:
+    # Try to get structured output by asking for JSON format
+    critic_result = critic.run_sync(critic_prompt)
+    critic_output = critic_result.output
+    
+    # Try to parse the output as JSON
+    try:
+        if isinstance(critic_output, str):
+            # Try to extract JSON from the string if it contains JSON
+            import re
+            json_match = re.search(r'\{.*\}', critic_output, re.DOTALL)
+            if json_match:
+                score = json.loads(json_match.group())
+            else:
+                # If no JSON found, create a structured response
+                score = {
+                    "insight": 7,  # Default values
+                    "civility": 8,
+                    "comment": critic_output
+                }
+        else:
+            score = critic_output
+    except json.JSONDecodeError:
+        # If JSON parsing fails, create structured response
+        score = {
+            "insight": 7,  # Default values
+            "civility": 8, 
+            "comment": critic_output
+        }
+    
+except Exception as e:
+    print(f"Error getting critic evaluation: {e}")
+    score = {
+        "insight": 0,
+        "civility": 0,
+        "comment": f"Error occurred during evaluation: {str(e)}"
+    }
+
+print(f"Score: {score}")
+
+# Write score to file
+try:
+    with open('score.json', 'w') as f:
+        json.dump(score, f, indent=2)
+    print("\nResults saved to score.json")
+except Exception as e:
+    print(f"Error saving to file: {e}")
+
+print("\nConversation completed!") 

gradio_test.py

@@ -0,0 +1,12 @@
+import gradio as gr
+
+def greet(name, intensity):
+    return "Hello, " + name + "!" * int(intensity)
+
+demo = gr.Interface(
+    fn=greet,
+    inputs=["text", "slider"],
+    outputs=["text"],
+)
+
+demo.launch()

main.py

@@ -0,0 +1,3 @@
+import marvin
+
+print(marvin.run("Write a haiku about artificial intelligence"))

mar_gr.py

@@ -0,0 +1,29 @@
+# file: marvin_gradio.py
+import marvin
+import gradio as gr
+
+# 1. Define an agent (feel free to tweak name / persona)
+assistant = marvin.Agent(
+    name="DocBot",
+    instructions="You are a concise, precise technical assistant."
+)
+
+# 2. A thread keeps context between turns -----------------
+thread_holder: dict[str, marvin.Thread] = {}
+
+def respond(user_msg: str, history):
+    # One Thread per browser tab    (history is supplied by Gradio)
+    thread = thread_holder.setdefault("t", marvin.Thread())
+    with thread:
+        reply = assistant.run(user_msg)  # sync call → str
+    return reply                          # Gradio expects a plain string
+
+# 3. Spin up the UI ----------------------------------------------------
+demo = gr.ChatInterface(
+    fn=respond,
+    title="Marvin + Gradio demo",
+    description="Ask me anything about your code, data or life."
+)
+
+if __name__ == "__main__":
+    demo.launch()        # localhost:7860 by default

marvin_gradio_examples.py

@@ -0,0 +1,71 @@
+import marvin
+import gradio as gr
+import asyncio
+
+# Example 1: Using Thread for context management
+def example_with_thread():
+    # Define an agent
+    assistant = marvin.Agent(
+        name="DocBot",
+        instructions="You are a concise, precise technical assistant."
+    )
+
+    # Thread holder for context management
+    thread_holder: dict[str, marvin.Thread] = {}
+
+    def respond(user_msg: str, history):
+        # One Thread per browser tab
+        thread = thread_holder.setdefault("t", marvin.Thread())
+        with thread:
+            # Use marvin.run() to ensure string output
+            reply = marvin.run(user_msg, agents=[assistant])
+        return str(reply)  # Ensure string output
+
+    # Create the interface
+    demo = gr.ChatInterface(
+        fn=respond,
+        title="Marvin + Gradio (Thread Example)",
+        description="Ask me anything about your code, data or life."
+    )
+    return demo
+
+# Example 2: Using async/await (Marvin v2 style)
+def example_with_async():
+    # Define an agent
+    bot = marvin.Agent(
+        name="Jokester",
+        instructions="Tell witty one-liners."
+    )
+
+    async def talk(msg, history):
+        try:
+            # Use marvin.run() with async to ensure string output
+            reply = await marvin.run(msg, agents=[bot])
+            return str(reply)  # Ensure string output
+        except Exception as e:
+            print(f"Error in talk function: {e}")
+            return f"Sorry, I encountered an error: {str(e)}"
+
+    # Create the interface with proper queue configuration
+    demo = gr.ChatInterface(
+        fn=talk,
+        title="Marvin + Gradio (Async Example)",
+        description="I'll tell you some jokes!"
+    )
+    
+    # Configure queue with proper settings
+    demo.queue(max_size=1)  # Limit queue size to 1
+    return demo
+
+if __name__ == "__main__":
+    # Choose which example to run
+    demo = example_with_thread()  # or example_with_async()
+    # demo = example_with_async()
+    
+    # Launch with proper async support
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        debug=True
+    ) 

marvin_test.py

@@ -0,0 +1,37 @@
+import marvin
+import json
+
+# define two speakers
+alice = marvin.Agent(name="Alice", instructions="You are a coach, speak like coach, start with question if no convo history ; you speak very concicely, one sentence at a time")
+bob   = marvin.Agent(name="Bob",   instructions="You have a problem with your kids. and speak very concicely, one sentence at a time")
+
+# simple ping-pong loop
+conversation = []
+for _ in range(3):
+    alice_msg = marvin.run("Your want to ask bob questions, help bob", agents=[alice], context={"history": conversation})
+    conversation.append(("Alice", alice_msg))
+
+    bob_msg   = marvin.run("Respond to Alice with your problem", agents=[bob], context={"history": conversation})
+    conversation.append(("Bob", bob_msg))
+    print(conversation)
+    input("Press Enter to continue...")
+
+# Convert conversation to a string format for the critic
+conversation_text = "\n\n".join([f"{speaker}: {message}" for speaker, message in conversation])
+
+# third agent evaluates
+critic = marvin.Agent(
+    name="Critic",
+    instructions=(
+        "Score the dialogue on insight (0-10) and civility (0-10); "
+        "return JSON with fields 'insight', 'civility', 'comment'."
+    )
+)
+score = marvin.run(f"Please evaluate this conversation:\n\n{conversation_text}", agents=[critic], result_type=dict)
+print(score)
+
+
+# Write score to file
+with open('score.json', 'w') as f:
+    json.dump(score, f, indent=2)
+

open2.py

@@ -0,0 +1,27 @@
+from openai import OpenAI
+client = OpenAI()
+
+response = client.chat.completions.create(
+  model="gpt-4.1-nano",
+  messages=[
+    {
+      "role": "user",
+      "content": [
+        {
+          "type": "text",
+          "text": "what is weather now"
+        }
+      ]
+    }
+  ],
+  response_format={
+    "type": "text"
+  },
+  temperature=1,
+  max_completion_tokens=2048,
+  top_p=1,
+  frequency_penalty=0,
+  presence_penalty=0
+)
+
+print(response)

pa.py

@@ -0,0 +1,12 @@
+from pydantic_ai import Agent
+
+agent = Agent(  
+    'openai:gpt-4o',
+    system_prompt='Be concise, reply with one sentence.',  
+)
+
+result = agent.run_sync('Where does "hello world" come from?')  
+print(result.output)
+"""
+The first known use of "hello, world" was in a 1974 textbook about the C programming language.
+"""

pa_fixed.py

@@ -0,0 +1,9 @@
+from pydantic_ai import Agent
+
+agent = Agent(  
+    'openai:gpt-4o',  # Fixed model name
+    system_prompt='Be concise, reply with one sentence.',  
+)
+
+result = agent.run_sync('Where does "hello world" come from?')  
+print(result.output) 

pa_simple_proxy.py

@@ -0,0 +1,31 @@
+import os
+import httpx
+from pydantic_ai import Agent
+
+# Ensure httpx uses the system proxy
+# httpx should automatically pick up proxy from environment variables
+# but let's make sure by setting trust_env=True
+
+print(f"System proxy settings:")
+print(f"  http_proxy: {os.environ.get('http_proxy', 'Not set')}")
+print(f"  https_proxy: {os.environ.get('https_proxy', 'Not set')}")
+
+# The issue might be that pydantic_ai creates its own httpx client
+# Let's try with the original simple approach
+agent = Agent(  
+    'openai:gpt-4o',
+    system_prompt='Be concise, reply with one sentence.',  
+)
+
+print("\nRunning agent (httpx should use system proxy automatically)...")
+try:
+    result = agent.run_sync('Where does "hello world" come from?')  
+    print(f"Response: {result.output}")
+except Exception as e:
+    print(f"Error: {type(e).__name__}: {e}")
+    
+    # Try to provide more debugging info
+    print("\nDebugging info:")
+    print("- Make sure your proxy is running on 127.0.0.1:7890")
+    print("- The proxy needs to support HTTPS connections")
+    print("- Check if the proxy requires authentication") 

pa_simple_test.py

@@ -0,0 +1,24 @@
+import asyncio
+from pydantic_ai import Agent
+import os
+
+# Set a longer timeout via environment variable if possible
+os.environ['HTTPX_TIMEOUT'] = '60'
+
+async def test_agent():
+    try:
+        agent = Agent(
+            'openai:gpt-4o',
+            system_prompt='Be concise, reply with one sentence.',
+        )
+        
+        print("Running agent asynchronously...")
+        result = await agent.run('Where does "hello world" come from?')
+        print(f"Response: {result.output}")
+        return result
+    except Exception as e:
+        print(f"Error: {type(e).__name__}: {e}")
+        return None
+
+# Run the async function
+result = asyncio.run(test_agent()) 

pa_with_client.py

@@ -0,0 +1,27 @@
+from pydantic_ai import Agent
+from pydantic_ai.models.openai import OpenAIModel
+from openai import AsyncOpenAI
+import httpx
+import asyncio
+
+# Create a custom HTTP client with longer timeout
+http_client = httpx.AsyncClient(timeout=httpx.Timeout(60.0))
+
+# Create OpenAI client with custom timeout
+openai_client = AsyncOpenAI(
+    http_client=http_client,
+    timeout=60.0
+)
+
+# Create the model with the custom client
+model = OpenAIModel('gpt-4o', openai_client=openai_client)
+
+# Create agent with the custom model
+agent = Agent(
+    model=model,
+    system_prompt='Be concise, reply with one sentence.',
+)
+
+print("Running agent with custom timeout...")
+result = agent.run_sync('Where does "hello world" come from?')
+print(f"Response: {result.output}") 

pa_with_proxy.py

@@ -0,0 +1,36 @@
+import os
+import httpx
+from pydantic_ai import Agent
+from pydantic_ai.models.openai import OpenAIModel
+from openai import AsyncOpenAI
+
+# Get proxy from environment
+proxy = os.environ.get('https_proxy', 'http://127.0.0.1:7890')
+print(f"Using proxy: {proxy}")
+
+# Create httpx client with proxy
+http_client = httpx.AsyncClient(
+    proxy=proxy,
+    timeout=httpx.Timeout(30.0)
+)
+
+# Create OpenAI client with the custom http client
+openai_client = AsyncOpenAI(
+    http_client=http_client
+)
+
+# Create the model
+model = OpenAIModel('gpt-4o', openai_client)
+
+# Create agent
+agent = Agent(
+    model=model,
+    system_prompt='Be concise, reply with one sentence.',
+)
+
+print("Running agent with proxy configuration...")
+try:
+    result = agent.run_sync('Where does "hello world" come from?')
+    print(f"Response: {result.output}")
+except Exception as e:
+    print(f"Error: {type(e).__name__}: {e}") 

pa_with_timeout.py

@@ -0,0 +1,32 @@
+import os
+from pydantic_ai import Agent
+import httpx
+
+# Create a custom HTTP client with longer timeout
+http_client = httpx.AsyncClient(timeout=httpx.Timeout(60.0))  # 60 second timeout
+
+try:
+    agent = Agent(  
+        'openai:gpt-4o',
+        system_prompt='Be concise, reply with one sentence.',
+        http_client=http_client
+    )
+
+    print("Running agent with question: 'Where does \"hello world\" come from?'")
+    result = agent.run_sync('Where does "hello world" come from?')  
+    print(f"Response: {result.output}")
+    
+except Exception as e:
+    print(f"Error occurred: {type(e).__name__}: {e}")
+    print("\nPossible causes:")
+    print("1. Network connectivity issues")
+    print("2. Invalid API key")
+    print("3. Rate limiting")
+    print("4. Firewall/proxy blocking the connection")
+    
+    # Check if API key is set
+    api_key = os.environ.get('OPENAI_API_KEY')
+    if api_key:
+        print(f"\nAPI key is set (starts with: {api_key[:10]}...)")
+    else:
+        print("\nNo OPENAI_API_KEY environment variable found!") 

pydantic_gradio.py

@@ -0,0 +1,37 @@
+from pydantic_ai import Agent
+import gradio as gr
+
+# Create a Pydantic AI agent
+agent = Agent(
+    'openai:gpt-4o',  # or your preferred model
+    system_prompt='You are a helpful assistant. Be concise and clear in your responses.'
+)
+
+def respond(message: str, history: list):
+    """
+    Handle chat messages using Pydantic AI agent.
+    
+    Args:
+        message: The user's input message
+        history: List of previous message pairs
+        
+    Returns:
+        The agent's response
+    """
+    # Convert history to context if needed
+    context = {"history": history} if history else {}
+    
+    # Get response from agent
+    result = agent.run_sync(message, context=context)
+    
+    return result.output
+
+# Create the Gradio interface
+demo = gr.ChatInterface(
+    fn=respond,
+    title="Pydantic AI Chat",
+    description="Chat with a Pydantic AI-powered assistant."
+)
+
+if __name__ == "__main__":
+    demo.launch() 

pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "uv-pg"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "gradio>=5.33.0",
+    "httpx>=0.28.1",
+    "marvin>=3.1.1",
+    "pydantic-ai>=0.2.15",
+]

score.json

@@ -0,0 +1,5 @@
+{
+  "insight": 7,
+  "civility": 10,
+  "comment": "The conversation provides practical advice on creating a structured routine to balance homework and playtime. Alice offers a constructive suggestion, and Bob appreciates and accepts it. The dialogue is civil, respectful, and helpful, with a focus on problem-solving. However, the conversation could delve deeper into more detailed strategies or examples for setting routines or managing children's time effectively, which would enhance the level of insight."
+}

test_openai_direct.py

@@ -0,0 +1,40 @@
+import os
+from openai import OpenAI
+import httpx
+
+# Test direct OpenAI API connection
+api_key = os.environ.get('OPENAI_API_KEY')
+if not api_key:
+    print("No OPENAI_API_KEY environment variable found!")
+    exit(1)
+
+print(f"Using API key: {api_key[:20]}...")
+
+try:
+    # Create client with custom timeout
+    client = OpenAI(
+        api_key=api_key,
+        timeout=30.0,  # 30 second timeout
+    )
+    
+    print("Testing OpenAI API connection...")
+    
+    # Try a simple completion
+    response = client.chat.completions.create(
+        model="gpt-4o",
+        messages=[
+            {"role": "system", "content": "You are a helpful assistant. Be concise."},
+            {"role": "user", "content": "Where does 'hello world' come from?"}
+        ],
+        max_tokens=100
+    )
+    
+    print(f"Success! Response: {response.choices[0].message.content}")
+    
+except Exception as e:
+    print(f"Error: {type(e).__name__}: {e}")
+    
+    # Try to get more details
+    if hasattr(e, 'response'):
+        print(f"Response status: {getattr(e.response, 'status_code', 'N/A')}")
+        print(f"Response text: {getattr(e.response, 'text', 'N/A')}")