pip install openai

from openai import OpenAI

# Initialize client with Eden AI endpoint
client = OpenAI(
    api_key="YOUR_EDEN_AI_API_KEY",  # Get from https://app.edenai.run
    base_url="https://api.edenai.run/v3/llm"
)

# Use streaming (mandatory in V3)
stream = client.chat.completions.create(
    model="openai/gpt-4",
    messages=[
        {"role": "user", "content": "Hello! How are you?"}
    ],
    stream=True
)

# Print the response
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end='')

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_EDEN_AI_API_KEY",
    base_url="https://api.edenai.run/v3/llm"
)

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "What is the capital of France?"}
]

# First interaction
stream = client.chat.completions.create(
    model="anthropic/claude-3-5-sonnet-20241022",
    messages=messages,
    stream=True
)

assistant_response = ""
for chunk in stream:
    if chunk.choices[0].delta.content:
        content = chunk.choices[0].delta.content
        print(content, end='')
        assistant_response += content

# Add assistant response to history
messages.append({"role": "assistant", "content": assistant_response})

# Continue conversation
messages.append({"role": "user", "content": "What's the population?"})

stream = client.chat.completions.create(
    model="anthropic/claude-3-5-sonnet-20241022",
    messages=messages,
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end='')

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_EDEN_AI_API_KEY",
    base_url="https://api.edenai.run/v3/llm"
)

stream = client.chat.completions.create(
    model="openai/gpt-4",
    messages=[
        {"role": "user", "content": "Write a creative story about AI."}
    ],
    temperature=0.9,           # Higher = more creative (0-2)
    max_tokens=500,            # Limit response length
    top_p=1.0,                 # Nucleus sampling
    frequency_penalty=0.0,     # Penalize repetition (-2 to 2)
    presence_penalty=0.0,      # Penalize topic repetition (-2 to 2)
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end='')

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_EDEN_AI_API_KEY",
    base_url="https://api.edenai.run/v3/llm"
)

# First, upload the image to get a file_id
import requests

upload_response = requests.post(
    "https://api.edenai.run/v3/upload",
    headers={"Authorization": f"Bearer YOUR_EDEN_AI_API_KEY"},
    files={"file": open("image.jpg", "rb")}
)
file_id = upload_response.json()["file_id"]

# Use the file_id in a chat message
stream = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What's in this image?"},
                {"type": "file", "file": {"file_id": file_id}}
            ]
        }
    ],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end='')

from openai import AsyncOpenAI
import asyncio

async def main():
    client = AsyncOpenAI(
        api_key="YOUR_EDEN_AI_API_KEY",
        base_url="https://api.edenai.run/v3/llm"
    )

    stream = await client.chat.completions.create(
        model="openai/gpt-4",
        messages=[
            {"role": "user", "content": "Hello!"}
        ],
        stream=True
    )

    async for chunk in stream:
        if chunk.choices[0].delta.content:
            print(chunk.choices[0].delta.content, end='')

asyncio.run(main())

from openai import OpenAI, OpenAIError
import openai

client = OpenAI(
    api_key="YOUR_EDEN_AI_API_KEY",
    base_url="https://api.edenai.run/v3/llm"
)

try:
    stream = client.chat.completions.create(
        model="openai/gpt-4",
        messages=[{"role": "user", "content": "Hello!"}],
        stream=True
    )

    for chunk in stream:
        if chunk.choices[0].delta.content:
            print(chunk.choices[0].delta.content, end='')

except openai.AuthenticationError as e:
    print(f"Authentication failed: {e}")
except openai.RateLimitError as e:
    print(f"Rate limit exceeded: {e}")
except openai.APIError as e:
    print(f"API error: {e}")
except Exception as e:
    print(f"Unexpected error: {e}")

from openai import OpenAI
import sys

def chat_with_ai():
    client = OpenAI(
        api_key="YOUR_EDEN_AI_API_KEY",
        base_url="https://api.edenai.run/v3/llm"
    )

    messages = [
        {"role": "system", "content": "You are a helpful assistant."}
    ]

    print("Chat with AI (type 'quit' to exit)")
    print("-" * 50)

    while True:
        # Get user input
        user_input = input("\nYou: ").strip()

        if user_input.lower() == 'quit':
            break

        if not user_input:
            continue

        # Add user message
        messages.append({"role": "user", "content": user_input})

        # Get AI response
        print("\nAssistant: ", end='')
        stream = client.chat.completions.create(
            model="anthropic/claude-3-5-sonnet-20241022",
            messages=messages,
            temperature=0.7,
            stream=True
        )

        assistant_response = ""
        for chunk in stream:
            if chunk.choices[0].delta.content:
                content = chunk.choices[0].delta.content
                print(content, end='', flush=True)
                assistant_response += content

        print()  # New line after response

        # Add assistant response to history
        messages.append({"role": "assistant", "content": assistant_response})

if __name__ == "__main__":
    chat_with_ai()

import requests

response = requests.get(
    "https://api.edenai.run/v3/llm/models",
    headers={"Authorization": "Bearer YOUR_EDEN_AI_API_KEY"}
)

models = response.json()

# Print models by provider
providers = {}
for model in models["data"]:
    provider = model["owned_by"]
    if provider not in providers:
        providers[provider] = []
    providers[provider].append(model["id"])

for provider, model_list in providers.items():
    print(f"\n{provider}:")
    for model_id in model_list:
        print(f"  - {model_id}")

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("EDEN_AI_API_KEY"),
    base_url="https://api.edenai.run/v3/llm"
)

from dotenv import load_dotenv
import os
from openai import OpenAI

load_dotenv()

client = OpenAI(
    api_key=os.getenv("EDEN_AI_API_KEY"),
    base_url="https://api.edenai.run/v3/llm"
)

import time
from openai import OpenAI, RateLimitError

client = OpenAI(
    api_key="YOUR_EDEN_AI_API_KEY",
    base_url="https://api.edenai.run/v3/llm"
)

def create_completion_with_retry(messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            return client.chat.completions.create(
                model="openai/gpt-4",
                messages=messages,
                stream=True
            )
        except RateLimitError:
            if attempt < max_retries - 1:
                wait_time = 2 ** attempt  # Exponential backoff
                print(f"Rate limited. Waiting {wait_time}s...")
                time.sleep(wait_time)
            else:
                raise