euriai 0.3.29__py3-none-any.whl → 0.4__py3-none-any.whl

euriai/__init__.py

@@ -4,6 +4,12 @@ from .embedding import EuriaiEmbeddingClient
 from .langchain_embed import EuriaiEmbeddings
 from .euri_chat import EuriaiLlamaIndexLLM
 from .euri_embed import EuriaiLlamaIndexEmbedding
+from .euri_crewai import EuriaiCrewAI
+from .euri_autogen import EuriaiAutoGen
+from .euri_llamaindex import EuriaiLlamaIndex
+from .euri_langgraph import EuriaiLangGraph
+from .euri_smolagents import EuriaiSmolAgent
+from .euri_n8n import EuriaiN8N
 
 __all__ = [
     "EuriaiClient",
@@ -11,5 +17,11 @@ __all__ = [
     "EuriaiEmbeddingClient",
     "EuriaiEmbeddings",
     "EuriaiLlamaIndexLLM",
-    "EuriaiLlamaIndexEmbedding"
+    "EuriaiLlamaIndexEmbedding",
+    "EuriaiCrewAI",
+    "EuriaiAutoGen",
+    "EuriaiLlamaIndex",
+    "EuriaiLangGraph",
+    "EuriaiSmolAgent",
+    "EuriaiN8N",
 ]

euriai/client.py

@@ -6,14 +6,14 @@ class EuriaiClient:
         self,
         api_key: str,
         model: str = "gpt-4.1-nano",
-        endpoint: str = "https://api.euron.one/api/v1/euri/alpha/chat/completions"
+        endpoint: str = "https://api.euron.one/api/v1/euri/chat/completions"
     ):
         """
         Initializes the EuriaiClient.
 
         Args:
             api_key (str): Your EURI API key.
-            model (str, optional): Model ID to use (e.g., 'gpt-4.1-nano', 'gemini-2.0-flash-001').
+            model (str, optional): Model ID to use (e.g., 'gpt-4.1-nano', 'gemini-2.5-flash').
             endpoint (str, optional): API endpoint URL.
         """
         self.api_key = api_key

euriai/embedding.py

@@ -5,7 +5,7 @@ class EuriaiEmbeddingClient:
     def __init__(self, api_key: str, model: str = "text-embedding-3-small"):
         self.api_key = api_key
         self.model = model
-        self.url = "https://api.euron.one/api/v1/euri/alpha/embeddings"
+        self.url = "https://api.euron.one/api/v1/euri/embeddings"
 
     def embed(self, text: str) -> np.ndarray:
         headers = {

euriai/euri_autogen.py

@@ -0,0 +1,74 @@
+from typing import Optional, Dict, Any, List
+
+try:
+    import autogen
+except ImportError:
+    autogen = None
+
+class EuriaiAutoGen:
+    """
+    Full-featured wrapper for AutoGen integration in the EURI SDK.
+    Allows programmatic agent, tool, and workflow management, and chat execution.
+    """
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """
+        Initialize the AutoGen wrapper.
+        Args:
+            config: Dict of config options (API keys, model, etc.)
+        """
+        if autogen is None:
+            raise ImportError("AutoGen is not installed. Please install with `pip install pyautogen`.")
+        self.config = config or {}
+        self.agents: List[Any] = []
+        self.tools: List[Any] = []
+        self.memory: Optional[Any] = None
+        self.workflow: Optional[Any] = None
+        self.history: List[Dict[str, Any]] = []
+
+    def add_agent(self, agent_config: Dict[str, Any]) -> Any:
+        """Add an agent with config."""
+        agent = autogen.Agent(**agent_config)
+        self.agents.append(agent)
+        return agent
+
+    def add_tool(self, tool_config: Dict[str, Any]) -> Any:
+        """Add a tool with config."""
+        tool = autogen.Tool(**tool_config)
+        self.tools.append(tool)
+        return tool
+
+    def set_memory(self, memory_config: Dict[str, Any]) -> None:
+        """Set memory for the workflow."""
+        self.memory = autogen.Memory(**memory_config)
+
+    def run_chat(self, prompt: str, agent_idx: int = 0, **kwargs) -> str:
+        """
+        Run a chat with the specified agent and prompt.
+        Returns the agent's response.
+        """
+        if not self.agents:
+            raise ValueError("No agents defined. Use add_agent().")
+        agent = self.agents[agent_idx]
+        response = agent.chat(prompt, **kwargs)
+        self.history.append({"agent": agent, "prompt": prompt, "response": response})
+        return response
+
+    def run_workflow(self, workflow_config: Dict[str, Any], **kwargs) -> Any:
+        """
+        Run a custom workflow (advanced usage).
+        """
+        workflow = autogen.Workflow(**workflow_config)
+        self.workflow = workflow
+        result = workflow.run(**kwargs)
+        return result
+
+    def get_history(self) -> List[Dict[str, Any]]:
+        return self.history
+
+    def reset(self):
+        """Reset agents, tools, memory, and history."""
+        self.agents = []
+        self.tools = []
+        self.memory = None
+        self.workflow = None
+        self.history = [] 

euriai/euri_chat.py

@@ -10,7 +10,7 @@ class EuriaiLlamaIndexLLM(LLM):
     model: str = "gpt-4.1-nano"
     temperature: float = 0.7
     max_tokens: int = 1000
-    url: str = "https://api.euron.one/api/v1/euri/alpha/chat/completions"
+    url: str = "https://api.euron.one/api/v1/euri/chat/completions"
 
     def __init__(
         self,

euriai/euri_crewai.py

@@ -0,0 +1,92 @@
+import os
+from typing import Optional, Dict, Any, List, Union
+
+# CrewAI imports (user must install crewai)
+try:
+    from crewai import Agent, Crew, Task, Process
+except ImportError:
+    Agent = Crew = Task = Process = None
+
+class EuriaiCrewAI:
+    """
+    Full-featured wrapper for CrewAI integration in the EURI SDK.
+    Allows programmatic and config-based crew creation, agent/task management, and workflow execution.
+    """
+    def __init__(self, agents: Optional[Dict[str, Any]] = None, tasks: Optional[Dict[str, Any]] = None, process: str = "sequential", verbose: bool = True):
+        """
+        Initialize the CrewAI wrapper.
+        Args:
+            agents: Dict of agent configs or Agent objects.
+            tasks: Dict of task configs or Task objects.
+            process: 'sequential' or 'parallel'.
+            verbose: Print detailed logs.
+        """
+        if Agent is None:
+            raise ImportError("CrewAI is not installed. Please install with `pip install crewai`.")
+        self.agents_config = agents or {}
+        self.tasks_config = tasks or {}
+        self.process = Process.sequential if process == "sequential" else Process.parallel
+        self.verbose = verbose
+        self._agents: List[Agent] = []
+        self._tasks: List[Task] = []
+        self._crew: Optional[Crew] = None
+
+    def add_agent(self, name: str, config: Dict[str, Any]) -> None:
+        """Add an agent by config."""
+        agent = Agent(**config)
+        self._agents.append(agent)
+        self.agents_config[name] = config
+
+    def add_task(self, name: str, config: Dict[str, Any]) -> None:
+        """Add a task by config."""
+        task = Task(**config)
+        self._tasks.append(task)
+        self.tasks_config[name] = config
+
+    def build_crew(self) -> Crew:
+        """Build the Crew object from current agents and tasks."""
+        if not self._agents:
+            self._agents = [Agent(**cfg) for cfg in self.agents_config.values()]
+        if not self._tasks:
+            self._tasks = [Task(**cfg) for cfg in self.tasks_config.values()]
+        self._crew = Crew(agents=self._agents, tasks=self._tasks, process=self.process, verbose=self.verbose)
+        return self._crew
+
+    def run(self, inputs: Optional[Dict[str, Any]] = None) -> Any:
+        """
+        Run the crew workflow. Optionally pass input variables for tasks.
+        Returns the final result or report.
+        """
+        if self._crew is None:
+            self.build_crew()
+        return self._crew.kickoff(inputs=inputs or {})
+
+    @classmethod
+    def from_yaml(cls, agents_yaml: str, tasks_yaml: str, process: str = "sequential", verbose: bool = True):
+        """
+        Create a CrewAI wrapper from YAML config files.
+        Args:
+            agents_yaml: Path to agents.yaml
+            tasks_yaml: Path to tasks.yaml
+        """
+        import yaml
+        with open(agents_yaml, "r") as f:
+            agents = yaml.safe_load(f)
+        with open(tasks_yaml, "r") as f:
+            tasks = yaml.safe_load(f)
+        return cls(agents=agents, tasks=tasks, process=process, verbose=verbose)
+
+    def get_agents(self) -> List[Agent]:
+        return self._agents
+
+    def get_tasks(self) -> List[Task]:
+        return self._tasks
+
+    def get_crew(self) -> Optional[Crew]:
+        return self._crew
+
+    def reset(self):
+        """Reset agents, tasks, and crew."""
+        self._agents = []
+        self._tasks = []
+        self._crew = None 

euriai/euri_embed.py

@@ -1,13 +1,13 @@
 import requests
 import numpy as np
-from typing import List, Optional
+from typing import List, Optional, Callable, Any
 from llama_index.core.embeddings import BaseEmbedding
 
 class EuriaiLlamaIndexEmbedding(BaseEmbedding):
     # Define class attributes as expected by Pydantic
     api_key: str
     model: str = "text-embedding-3-small"
-    url: str = "https://api.euron.one/api/v1/euri/alpha/embeddings"
+    url: str = "https://api.euron.one/api/v1/euri/embeddings"
 
     def __init__(self, api_key: str, model: Optional[str] = None):
         """Initialize embedding model with API key and model name."""
@@ -38,6 +38,15 @@ class EuriaiLlamaIndexEmbedding(BaseEmbedding):
         """Get embedding for a single text."""
         return self._post_embedding([text])[0]
 
+    def get_query_embedding(self, query: str) -> List[float]:
+        """Get embedding for a query string."""
+        return self.get_text_embedding(query)
+        
     def get_text_embeddings(self, texts: List[str]) -> List[List[float]]:
         """Get embeddings for multiple texts."""
-        return self._post_embedding(texts)
+        return self._post_embedding(texts)
+        
+    async def aget_query_embedding(self, query: str) -> List[float]:
+        """Async version of get_query_embedding."""
+        # We don't support async, so raise NotImplementedError
+        raise NotImplementedError("Async embeddings not supported")

euriai/euri_langgraph.py

@@ -0,0 +1,64 @@
+from typing import Any, Callable, Dict, List, Optional, Union
+
+try:
+    from langgraph.graph import StateGraph
+except ImportError:
+    StateGraph = None
+
+class EuriaiLangGraph:
+    """
+    Full-featured wrapper for LangGraph integration in the EURI SDK.
+    Allows programmatic graph construction, node/edge management, and workflow execution.
+    """
+    def __init__(self, name: str = "EuriaiLangGraph", state: Optional[Dict[str, Any]] = None):
+        """
+        Initialize the LangGraph wrapper.
+        Args:
+            name: Name of the graph.
+            state: Initial state dictionary.
+        """
+        if StateGraph is None:
+            raise ImportError("LangGraph is not installed. Please install with `pip install langgraph`.")
+        self.name = name
+        self.state = state or {}
+        self.graph = StateGraph()
+        self.nodes: Dict[str, Callable] = {}
+        self.edges: List[tuple] = []
+
+    def add_node(self, node_name: str, node_fn: Callable) -> None:
+        """Add a node to the graph."""
+        self.graph.add_node(node_name, node_fn)
+        self.nodes[node_name] = node_fn
+
+    def add_edge(self, from_node: str, to_node: str) -> None:
+        """Add an edge between two nodes."""
+        self.graph.add_edge(from_node, to_node)
+        self.edges.append((from_node, to_node))
+
+    def set_state(self, state: Dict[str, Any]) -> None:
+        """Set the initial state for the graph execution."""
+        self.state = state
+
+    def run(self, input_state: Optional[Dict[str, Any]] = None, **kwargs) -> Any:
+        """
+        Run the graph workflow with the given state.
+        Returns the final state/output.
+        """
+        state = input_state or self.state
+        return self.graph.run(state, **kwargs)
+
+    def get_nodes(self) -> Dict[str, Callable]:
+        return self.nodes
+
+    def get_edges(self) -> List[tuple]:
+        return self.edges
+
+    def get_graph(self) -> Any:
+        return self.graph
+
+    def reset(self):
+        """Reset the graph, nodes, and edges."""
+        self.graph = StateGraph()
+        self.nodes = {}
+        self.edges = []
+        self.state = {} 

euriai/euri_llamaindex.py

@@ -0,0 +1,58 @@
+from typing import Optional, List, Any, Dict, Union
+
+try:
+    from llama_index.core import VectorStoreIndex, ServiceContext
+    from llama_index.core.llms import LLM
+    from llama_index.core.schema import Document
+except ImportError:
+    VectorStoreIndex = ServiceContext = LLM = Document = None
+
+class EuriaiLlamaIndex:
+    """
+    Full-featured wrapper for LlamaIndex integration in the EURI SDK.
+    Allows document ingestion, index building, and querying with advanced config.
+    """
+    def __init__(self, llm: Optional[Any] = None, service_context: Optional[Any] = None):
+        """
+        Initialize the LlamaIndex wrapper.
+        Args:
+            llm: LLM object (optional)
+            service_context: ServiceContext object (optional)
+        """
+        if VectorStoreIndex is None:
+            raise ImportError("LlamaIndex is not installed. Please install with `pip install llama_index`.")
+        self.llm = llm
+        self.service_context = service_context or (ServiceContext.from_defaults(llm=llm) if llm else ServiceContext.from_defaults())
+        self.index: Optional[Any] = None
+        self.documents: List[Any] = []
+
+    def add_documents(self, docs: List[Union[str, Dict[str, Any]]]) -> None:
+        """Add documents (as strings or dicts) to the index."""
+        for doc in docs:
+            if isinstance(doc, str):
+                self.documents.append(Document(text=doc))
+            elif isinstance(doc, dict):
+                self.documents.append(Document(**doc))
+            else:
+                raise ValueError("Document must be str or dict.")
+
+    def build_index(self) -> None:
+        """Build the vector index from current documents."""
+        self.index = VectorStoreIndex.from_documents(self.documents)
+
+    def query(self, query: str, **kwargs) -> Any:
+        """
+        Query the index with a string. Returns the response object.
+        """
+        if self.index is None:
+            self.build_index()
+        query_engine = self.index.as_query_engine(service_context=self.service_context)
+        return query_engine.query(query, **kwargs)
+
+    def get_index(self) -> Optional[Any]:
+        return self.index
+
+    def reset(self):
+        """Reset documents and index."""
+        self.documents = []
+        self.index = None 

euriai/euri_n8n.py

@@ -0,0 +1,30 @@
+import requests
+from typing import Any, Dict, Optional
+
+class EuriaiN8N:
+    """
+    Wrapper for n8n workflow automation integration in the EURI SDK.
+    Allows triggering n8n workflows and exchanging data via REST API.
+    """
+    def __init__(self, base_url: str, api_key: Optional[str] = None):
+        """
+        Initialize the n8n wrapper.
+        Args:
+            base_url: Base URL of the n8n instance (e.g., http://localhost:5678 or cloud URL)
+            api_key: Optional API key for authentication
+        """
+        self.base_url = base_url.rstrip('/')
+        self.api_key = api_key
+
+    def trigger_workflow(self, workflow_id: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Trigger an n8n workflow by ID, optionally passing data.
+        Returns the workflow execution response.
+        """
+        url = f"{self.base_url}/webhook/{workflow_id}"
+        headers = {}
+        if self.api_key:
+            headers["Authorization"] = f"Bearer {self.api_key}"
+        response = requests.post(url, json=data or {}, headers=headers)
+        response.raise_for_status()
+        return response.json() 

euriai/euri_smolagents.py

@@ -0,0 +1,44 @@
+from typing import Any, Callable, Dict, List, Optional
+
+try:
+    from smolagents import CodeAgent, HfApiModel, tool
+except ImportError:
+    CodeAgent = HfApiModel = tool = None
+
+class EuriaiSmolAgent:
+    """
+    Full-featured wrapper for SmolAgents integration in the EURI SDK.
+    Allows agent creation, tool integration, and task execution.
+    """
+    def __init__(self, model: Optional[Any] = None, tools: Optional[List[Callable]] = None):
+        """
+        Initialize the SmolAgent wrapper.
+        Args:
+            model: LLM model (default: HfApiModel())
+            tools: List of tool functions (decorated with @tool)
+        """
+        if CodeAgent is None:
+            raise ImportError("SmolAgents is not installed. Please install with `pip install smolagents`.")
+        self.model = model or HfApiModel()
+        self.tools = tools or []
+        self.agent = CodeAgent(tools=self.tools, model=self.model)
+
+    def add_tool(self, tool_fn: Callable) -> None:
+        """Add a tool to the agent."""
+        self.tools.append(tool_fn)
+        self.agent = CodeAgent(tools=self.tools, model=self.model)
+
+    def run(self, prompt: str, **kwargs) -> Any:
+        """
+        Run the agent on a prompt/task.
+        Returns the agent's response.
+        """
+        return self.agent.run(prompt, **kwargs)
+
+    def get_agent(self) -> Any:
+        return self.agent
+
+    def reset(self):
+        """Reset the agent and tools."""
+        self.tools = []
+        self.agent = CodeAgent(tools=self.tools, model=self.model) 

euriai/langchain_embed.py

@@ -1,4 +1,7 @@
-from langchain_core.embeddings import Embeddings
+try:
+    from langchain_core.embeddings import Embeddings
+except ImportError:
+    raise ImportError("LangChain is not installed. Please install with 'pip install euriai[langchain]' or 'pip install langchain'.")
 from typing import List
 from euriai.embedding import EuriaiEmbeddingClient
 

euriai/langchain_llm.py

@@ -1,4 +1,7 @@
-from langchain.llms.base import LLM
+try:
+    from langchain.llms.base import LLM
+except ImportError:
+    raise ImportError("LangChain is not installed. Please install with 'pip install euriai[langchain]' or 'pip install langchain'.")
 from typing import Optional, List
 from euriai import EuriaiClient
 

euriai-0.4.dist-info/METADATA

@@ -0,0 +1,282 @@
+Metadata-Version: 2.4
+Name: euriai
+Version: 0.4
+Summary: Python client for Euri API (euron.one) with CLI, LangChain, and LlamaIndex integration
+Author: Euri
+Author-email: tech@euron.one
+License: MIT
+Keywords: euriai,llm,langchain,llamaindex,langgraph,smolagents,n8n,agents,ai,sdk
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: numpy
+Requires-Dist: pyyaml
+Provides-Extra: langchain-core
+Requires-Dist: langchain-core; extra == "langchain-core"
+Provides-Extra: langchain
+Requires-Dist: langchain; extra == "langchain"
+Provides-Extra: llama-index
+Requires-Dist: llama-index>=0.10.0; extra == "llama-index"
+Provides-Extra: langgraph
+Requires-Dist: langgraph; extra == "langgraph"
+Provides-Extra: smolagents
+Requires-Dist: smolagents; extra == "smolagents"
+Provides-Extra: n8n
+Requires-Dist: requests; extra == "n8n"
+Provides-Extra: crewai
+Requires-Dist: crewai; extra == "crewai"
+Provides-Extra: autogen
+Requires-Dist: pyautogen; extra == "autogen"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# euriai 🧠 
+
+**EURI AI Python Client** – A simple wrapper and CLI tool for the [Euri API](https://euron.one/euri). Supports completions, streaming responses, embeddings, CLI interaction, and an interactive guided wizard!
+
+---
+
+## 🔧 Installation 
+
+```bash
+pip install euriai
+```
+
+## 🚀 Python Usage
+
+### Text Generation
+
+```python
+from euriai import EuriaiClient
+
+client = EuriaiClient(
+    api_key="your_api_key_here",
+    model="gpt-4.1-nano"  # You can also try: "gemini-2.0-flash-001", "llama-4-maverick", etc.
+)
+
+response = client.generate_completion(
+    prompt="Write a short poem about artificial intelligence.",
+    temperature=0.7,
+    max_tokens=300
+)
+
+print(response)
+```
+
+### Embeddings
+
+```python
+from euriai.embedding import EuriaiEmbeddingClient
+
+client = EuriaiEmbeddingClient(api_key="your_key")
+embedding = client.embed("Hello world")
+print(embedding[:5])  # Print first 5 dimensions of the embedding vector
+```
+
+## 💻 Command-Line Interface (CLI) Usage
+
+Run prompts directly from the terminal:
+
+```bash
+euriai --api_key YOUR_API_KEY --prompt "Tell me a joke"
+```
+
+Enable streaming output (if supported by the model):
+
+```bash
+euriai --api_key YOUR_API_KEY --prompt "Stream a fun fact" --stream
+```
+
+List all supported model IDs with recommended use-cases and temperature/token advice:
+
+```bash
+euriai --models
+```
+
+## 🤖 LangChain Integration
+
+### Text Generation
+
+Use Euriai with LangChain directly:
+
+```python
+from euriai import EuriaiLangChainLLM
+
+llm = EuriaiLangChainLLM(
+    api_key="your_api_key",
+    model="gpt-4.1-nano", 
+    temperature=0.7,
+    max_tokens=300
+)
+
+print(llm.invoke("Write a poem about time travel."))
+```
+
+### Embeddings
+
+Use Euriai embeddings with LangChain:
+
+```python
+from euriai.langchain_embed import EuriaiEmbeddings
+
+embedding_model = EuriaiEmbeddings(api_key="your_key")
+print(embedding_model.embed_query("What's AI?")[:5])  # Print first 5 dimensions
+```
+
+## Usage Examples
+
+### CrewAI Integration
+```python
+from euriai import EuriaiCrewAI
+
+# Example: Create a crew from YAML config files
+crew = EuriaiCrewAI.from_yaml('agents.yaml', 'tasks.yaml')
+result = crew.run(inputs={"topic": "AI in Healthcare"})
+print(result)
+
+# Or programmatically
+crew = EuriaiCrewAI()
+crew.add_agent("researcher", {
+    "role": "Researcher",
+    "goal": "Find information about {topic}",
+    "llm": "openai/gpt-4o"
+})
+crew.add_task("research_task", {
+    "description": "Research the topic {topic}",
+    "agent": "researcher"
+})
+crew.build_crew()
+result = crew.run(inputs={"topic": "AI in Healthcare"})
+print(result)
+```
+
+### AutoGen Integration
+```python
+from euriai import EuriaiAutoGen
+
+autogen = EuriaiAutoGen()
+# Add an agent (see AutoGen docs for agent config details)
+agent = autogen.add_agent({
+    "name": "assistant",
+    "llm_config": {"api_key": "YOUR_OPENAI_KEY", "model": "gpt-4o"}
+})
+# Run a chat
+response = autogen.run_chat("Hello, what is the weather today?")
+print(response)
+# Access chat history
+print(autogen.get_history())
+```
+
+### LlamaIndex Integration
+```python
+from euriai import EuriaiLlamaIndex
+
+llama = EuriaiLlamaIndex()
+llama.add_documents([
+    "Abraham Lincoln was the 16th President of the United States.",
+    "He led the country during the American Civil War."
+])
+llama.build_index()
+response = llama.query("Who was Abraham Lincoln?")
+print(response)
+```
+
+### LangGraph Integration
+```python
+from euriai import EuriaiLangGraph
+
+def greet_node(state):
+    print(f"Hello, {state['name']}!")
+    state['greeted'] = True
+    return state
+
+def farewell_node(state):
+    if state.get('greeted'):
+        print(f"Goodbye, {state['name']}!")
+    return state
+
+# Create the graph
+graph = EuriaiLangGraph()
+graph.add_node("greet", greet_node)
+graph.add_node("farewell", farewell_node)
+graph.add_edge("greet", "farewell")
+graph.set_state({"name": "Alice"})
+result = graph.run()
+print(result)
+```
+
+---
+
+## 2. **SmolAgents Integration**
+
+```python
+from euriai import EuriaiSmolAgent
+
+# Define a tool using the @tool decorator
+try:
+    from smolagents import tool
+except ImportError:
+    raise ImportError("Please install smolagents: pip install smolagents")
+
+@tool
+def add(a: int, b: int) -> int:
+    """Add two numbers."""
+    return a + b
+
+# Create the agent with the tool
+agent = EuriaiSmolAgent(tools=[add])
+response = agent.run("What is 2 + 3?")
+print(response)
+```
+
+---
+
+## 3. **n8n Integration**
+
+```python
+from euriai import EuriaiN8N
+
+# Initialize with your n8n instance URL and (optionally) API key
+n8n = EuriaiN8N(base_url="http://localhost:5678", api_key="YOUR_N8N_API_KEY")
+
+# Trigger a workflow by its webhook ID, passing data as needed
+workflow_id = "your-workflow-webhook-id"
+data = {"message": "Hello from EURI SDK!"}
+result = n8n.trigger_workflow(workflow_id, data)
+print(result)
+```
+
+---
+
+**You can copy-paste these code blocks into your client documentation or UI for user reference.**  
+If you want advanced examples (e.g., multi-tool SmolAgents, LangGraph with more nodes, or n8n with authentication), just let me know!
+
+## 📘 Documentation
+
+For full documentation, visit our [official docs site](https://euron.one/euri).
+
+## 🔑 Getting an API Key
+
+Sign up for an API key at [Euron AI Platform](https://euron.one/euri).
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## 📄 License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

euriai-0.4.dist-info/RECORD

@@ -0,0 +1,19 @@
+euriai/__init__.py,sha256=JaXTVZFPARYHzpICgl-F5hd5OCYcwG0IOdTXV4wsrK4,835
+euriai/cli.py,sha256=hF1wiiL2QQSfWf8WlLQyNVDBd4YkbiwmMSoPxVbyPTM,3290
+euriai/client.py,sha256=L-o6hv9N3md-l-hz-kz5nYVaaZqnrREZlo_0jguhF7E,4066
+euriai/embedding.py,sha256=uP66Ph1k9Ou6J5RAkztJxlfyj0S0MESOvZ4ulhnVo-o,1270
+euriai/euri_autogen.py,sha256=OSrQJbbPXXgZ5bubofxnvq-dabs8B8G2dfSHn-LCbw0,2515
+euriai/euri_chat.py,sha256=DEAiet1ReRwB4ljkPYaTl1Nb5uc20-JF-3PQjGQZXk4,3567
+euriai/euri_crewai.py,sha256=1Z_lqHr4Jn0mt7jTsh8JXWdjpC_q1AhN-Mm6PDigG10,3443
+euriai/euri_embed.py,sha256=VE-RLUb5bYnEFA_dxFkj2c3Jr_SYyJKPmFOzsDOR0Ys,2137
+euriai/euri_langgraph.py,sha256=x8RNSrdcCzY6AunNNHzeX3297srecNUwHdDLTrBb1u8,2131
+euriai/euri_llamaindex.py,sha256=AVBgfm_cQiZEpfcIAcMeIs55eW_SvDPJPZ31Y_blN0I,2281
+euriai/euri_n8n.py,sha256=8JvEgvq14ZI7k5_Rfimpbht4RtYSwMh2gKyo1H4Wl6M,1148
+euriai/euri_smolagents.py,sha256=RcxwI9coXF_DmIy_0TqEF737CIIpZn8f0p_9G5rSFpY,1530
+euriai/langchain_embed.py,sha256=9nZgD_99CCpsGvXpLUW-Gklxp-pJ4IMhO8ZfbesqLyI,749
+euriai/langchain_llm.py,sha256=BKNg1i48EAciEXyBVK7_Y9glkhLGWF_OfkKPzvnLtB0,1151
+euriai-0.4.dist-info/METADATA,sha256=G0fouJYynkW0KG8mcqABkL5TKbEoLLwAJSInBSOgHxg,6879
+euriai-0.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+euriai-0.4.dist-info/entry_points.txt,sha256=9OkET8KIGcsjQn8UlnpPKRT75s2KW34jq1__1SXtpMA,43
+euriai-0.4.dist-info/top_level.txt,sha256=TG1htJ8cuD62MXn-NJ7DVF21QHY16w6M_QgfF_Er_EQ,7
+euriai-0.4.dist-info/RECORD,,

{euriai-0.3.29.dist-info → euriai-0.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

euriai-0.3.29.dist-info/METADATA

@@ -1,135 +0,0 @@
-Metadata-Version: 2.4
-Name: euriai
-Version: 0.3.29
-Summary: Python client for EURI LLM API (euron.one) with CLI, LangChain, and LlamaIndex integration
-Author: euron.one
-Author-email: sudhanshu@euron.one
-License: MIT
-Classifier: Programming Language :: Python :: 3
-Classifier: Operating System :: OS Independent
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Intended Audience :: Developers
-Requires-Python: >=3.6
-Description-Content-Type: text/markdown
-Requires-Dist: requests
-Requires-Dist: langchain-core
-Requires-Dist: llama-index>=0.10.0
-Requires-Dist: numpy
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: license
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-# euriai 🧠 
-
-**EURI AI Python Client** – A simple wrapper and CLI tool for the [Euron LLM API](https://euron.one/euri/api). Supports completions, streaming responses, embeddings, CLI interaction, and an interactive guided wizard!
-
----
-
-## 🔧 Installation 
-
-```bash
-pip install euriai
-```
-
-## 🚀 Python Usage
-
-### Text Generation
-
-```python
-from euriai import EuriaiClient
-
-client = EuriaiClient(
-    api_key="your_api_key_here",
-    model="gpt-4.1-nano"  # You can also try: "gemini-2.0-flash-001", "llama-4-maverick", etc.
-)
-
-response = client.generate_completion(
-    prompt="Write a short poem about artificial intelligence.",
-    temperature=0.7,
-    max_tokens=300
-)
-
-print(response)
-```
-
-### Embeddings
-
-```python
-from euriai.embedding import EuriaiEmbeddingClient
-
-client = EuriaiEmbeddingClient(api_key="your_key")
-embedding = client.embed("Hello world")
-print(embedding[:5])  # Print first 5 dimensions of the embedding vector
-```
-
-## 💻 Command-Line Interface (CLI) Usage
-
-Run prompts directly from the terminal:
-
-```bash
-euriai --api_key YOUR_API_KEY --prompt "Tell me a joke"
-```
-
-Enable streaming output (if supported by the model):
-
-```bash
-euriai --api_key YOUR_API_KEY --prompt "Stream a fun fact" --stream
-```
-
-List all supported model IDs with recommended use-cases and temperature/token advice:
-
-```bash
-euriai --models
-```
-
-## 🤖 LangChain Integration
-
-### Text Generation
-
-Use Euriai with LangChain directly:
-
-```python
-from euriai import EuriaiLangChainLLM
-
-llm = EuriaiLangChainLLM(
-    api_key="your_api_key",
-    model="gpt-4.1-nano", 
-    temperature=0.7,
-    max_tokens=300
-)
-
-print(llm.invoke("Write a poem about time travel."))
-```
-
-### Embeddings
-
-Use Euriai embeddings with LangChain:
-
-```python
-from euriai.langchain_embed import EuriaiEmbeddings
-
-embedding_model = EuriaiEmbeddings(api_key="your_key")
-print(embedding_model.embed_query("What's AI?")[:5])  # Print first 5 dimensions
-```
-
-## 📘 Documentation
-
-For full documentation, visit our [official docs site](https://euron.one/euri/api).
-
-## 🔑 Getting an API Key
-
-Sign up for an API key at [Euron AI Platform](https://euron.one/euri/api).
-
-## 🤝 Contributing
-
-Contributions are welcome! Please feel free to submit a Pull Request.
-
-## 📄 License
-
-This project is licensed under the MIT License - see the LICENSE file for details.

euriai-0.3.29.dist-info/RECORD

@@ -1,13 +0,0 @@
-euriai/__init__.py,sha256=8YhbRV8s4wmNxDP9KmjOxQYLgKUCke450vnp-8-kPKs,449
-euriai/cli.py,sha256=hF1wiiL2QQSfWf8WlLQyNVDBd4YkbiwmMSoPxVbyPTM,3290
-euriai/client.py,sha256=USiqdMULgAiky7nkrJKF3FyKcOS2DtDmUdbeBSnyLYk,4076
-euriai/embedding.py,sha256=z-LLKU68tCrPi9QMs1tlKwyr7WJcjceCTkNQIFMG6vA,1276
-euriai/euri_chat.py,sha256=tuNhwyyzZTSJjX4Su8XBftp7a5YtsalerglNhho2fpA,3573
-euriai/euri_embed.py,sha256=SifhobAIAFuwt9x7K_f1uNhxuK14O2STtUCNC6TVApI,1693
-euriai/langchain_embed.py,sha256=OXWWxiKJ4g24TFgnWPOCZvhK7G8xtSf0ppQ2zwHkIPM,584
-euriai/langchain_llm.py,sha256=D5YvYwV7q9X2_vdoaQiPs7tNiUmjkGz-9Q-7M61hhkg,986
-euriai-0.3.29.dist-info/METADATA,sha256=4V-uSeO1P7k0LmgtsSW3-gLX4_StMOoHNysS_ucvU3A,3249
-euriai-0.3.29.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-euriai-0.3.29.dist-info/entry_points.txt,sha256=9OkET8KIGcsjQn8UlnpPKRT75s2KW34jq1__1SXtpMA,43
-euriai-0.3.29.dist-info/top_level.txt,sha256=TG1htJ8cuD62MXn-NJ7DVF21QHY16w6M_QgfF_Er_EQ,7
-euriai-0.3.29.dist-info/RECORD,,