OpenAI Compatibility

1
# Complete Request & Response
2
from openai import OpenAI
3
4
client = OpenAI(
5
    api_key="YOUR_ASI_ONE_API_KEY",
6
    base_url="https://api.asi1.ai/v1"
7
)
8
9
response = client.chat.completions.create(
10
    model="asi1",
11
    messages=[
12
        {"role": "system", "content": "Be precise and concise."},
13
        {"role": "user", "content": "What is agentic AI and how does it work?"}
14
    ],
15
    temperature=0.2,
16
    top_p=0.9,
17
    max_tokens=1000,
18
    presence_penalty=0,
19
    frequency_penalty=0,
20
    stream=False,
21
    extra_body={
22
        "web_search": False
23
    }
24
)
25
26
print(response.choices[0].message.content)
27
print(f"Usage: {response.usage}")

1
# Agentic Model with Session - Working Example
2
import uuid
3
from openai import OpenAI
4
5
client = OpenAI(
6
    api_key="YOUR_ASI_ONE_API_KEY",
7
    base_url="https://api.asi1.ai/v1"
8
)
9
10
# Generate session ID for agentic models
11
session_id = str(uuid.uuid4())
12
13
print(f"🆔 Session ID: {session_id}")
14
print("🔄 Making request to agentic...")
15
16
response = client.chat.completions.create(
17
    model="asi1",
18
    messages=[
19
        {"role": "user", "content": "Check latest flights arrival status on Delhi airport."}
20
    ],
21
    extra_headers={
22
        "x-session-id": session_id
23
    },
24
    temperature=0.7,
25
    stream=True
26
)
27
28
print("📡 Response received, streaming content:\n")
29
30
# Handle streaming response safely
31
for chunk in response:
32
    # Safe check for choices and content
33
    if (hasattr(chunk, 'choices') and
34
        chunk.choices and
35
        len(chunk.choices) > 0 and
36
        hasattr(chunk.choices[0], 'delta') and
37
        hasattr(chunk.choices[0].delta, 'content') and
38
        chunk.choices[0].delta.content):
39
40
        print(chunk.choices[0].delta.content, end="")
41
42
print("\n\n🏁 Stream completed!")

1
# Web Search Integration
2
from openai import OpenAI
3
4
client = OpenAI(
5
    api_key="YOUR_ASI_ONE_API_KEY",
6
    base_url="https://api.asi1.ai/v1"
7
)
8
9
response = client.chat.completions.create(
10
    model="asi1",
11
    messages=[
12
        {"role": "user", "content": "Latest developments in AI research"}
13
    ],
14
    extra_body={
15
        "web_search": True
16
    }
17
)
18
19
print(response.choices[0].message.content)

1
# Accessing response fields
2
print(response.choices[0].message.content)  # Main answer
3
print(response.model)                       # Model name
4
print(response.usage)                       # Token usage
5
6
# ASI:One specific fields
7
8
if hasattr(response, 'executable_data'):
9
print(response.executable_data) # Agent calls
10
if hasattr(response, 'intermediate_steps'):
11
print(response.intermediate_steps) # Reasoning steps
12
if hasattr(response, 'thought'):
13
print(response.thought) # Model thinking

1
# Basic LangChain Integration
2
import os
3
from langchain_openai import ChatOpenAI
4
from langchain_core.messages import HumanMessage, SystemMessage
5
6
llm = ChatOpenAI(
7
    model="asi1",
8
    base_url="https://api.asi1.ai/v1",
9
    api_key=os.getenv("ASI_ONE_API_KEY"),
10
    temperature=0.7,
11
)
12
13
messages = [
14
    SystemMessage(content="You are a helpful AI assistant."),
15
    HumanMessage(content="What is agentic AI?")
16
]
17
18
response = llm.invoke(messages)
19
print(response.content)

1
# Streaming with LangChain
2
import os
3
from langchain_openai import ChatOpenAI
4
from langchain_core.messages import HumanMessage
5
6
llm = ChatOpenAI(
7
    model="asi1",
8
    base_url="https://api.asi1.ai/v1",
9
    api_key=os.getenv("ASI_ONE_API_KEY"),
10
    streaming=True,
11
)
12
13
for chunk in llm.stream([HumanMessage(content="Explain blockchain in simple terms")]):
14
    print(chunk.content, end="", flush=True)

1
# Structured Output with Pydantic
2
import os
3
from langchain_openai import ChatOpenAI
4
from langchain_core.messages import HumanMessage
5
from pydantic import BaseModel, Field
6
7
class MovieRecommendation(BaseModel):
8
    """A movie recommendation with details."""
9
    title: str = Field(description="The movie title")
10
    year: int = Field(description="Release year")
11
    genre: str = Field(description="Primary genre")
12
    reason: str = Field(description="Why this movie is recommended")
13
14
llm = ChatOpenAI(
15
    model="asi1",
16
    base_url="https://api.asi1.ai/v1",
17
    api_key=os.getenv("ASI_ONE_API_KEY"),
18
)
19
20
# Use with_structured_output for type-safe responses
21
structured_llm = llm.with_structured_output(MovieRecommendation)
22
23
result = structured_llm.invoke("Recommend a sci-fi movie for someone who loved Inception")
24
print(f"Title: {result.title}")
25
print(f"Year: {result.year}")
26
print(f"Genre: {result.genre}")
27
print(f"Reason: {result.reason}")

1
# LangChain with Tool Calling
2
import os
3
from langchain_openai import ChatOpenAI
4
from langchain_core.tools import tool
5
6
@tool
7
def get_weather(city: str) -> str:
8
    """Get the current weather for a city."""
9
    # In production, call a real weather API
10
    return f"The weather in {city} is sunny, 22°C"
11
12
@tool
13
def search_restaurants(city: str, cuisine: str) -> str:
14
    """Search for restaurants in a city by cuisine type."""
15
    return f"Found 5 {cuisine} restaurants in {city}"
16
17
llm = ChatOpenAI(
18
    model="asi1",
19
    base_url="https://api.asi1.ai/v1",
20
    api_key=os.getenv("ASI_ONE_API_KEY"),
21
)
22
23
# Bind tools to the model
24
llm_with_tools = llm.bind_tools([get_weather, search_restaurants])
25
26
response = llm_with_tools.invoke("What's the weather in Tokyo and find me some sushi restaurants there?")
27
print(response.tool_calls)