euriai 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

euriai/__init__.py

@@ -1,30 +1,118 @@
+"""
+Euri AI Python SDK
+
+A comprehensive Python SDK for the Euri AI API with integrations for popular frameworks.
+"""
+
 from .client import EuriaiClient
-from .langchain import EuriaiChatModel, EuriaiEmbeddings, EuriaiLLM, create_chat_model, create_embeddings, create_llm
-from .embedding import EuriaiEmbeddingClient
-from .euri_chat import EuriaiLlamaIndexLLM
-from .euri_embed import EuriaiLlamaIndexEmbedding
-from .crewai import EuriaiCrewAI
-from .autogen import EuriaiAutoGen
-from .llamaindex import EuriaiLlamaIndex
-from .langgraph import EuriaiLangGraph
-from .smolagents import EuriaiSmolAgent
-from .n8n import EuriaiN8N
+from .embedding import EuriaiEmbedding
+
+# Version
+__version__ = "1.0.5"
 
+# Main exports
 __all__ = [
-    "EuriaiClient",
-    "EuriaiEmbeddingClient",
-    "EuriaiLlamaIndexLLM",
-    "EuriaiLlamaIndexEmbedding",
-    "EuriaiCrewAI",
-    "EuriaiAutoGen",
-    "EuriaiLlamaIndex",
-    "EuriaiLangGraph",
-    "EuriaiSmolAgent",
-    "EuriaiN8N",
-    "EuriaiChatModel",
-    "EuriaiEmbeddings",
-    "EuriaiLLM",
-    "create_chat_model",
-    "create_embeddings",
-    "create_llm",
-]
+    "EuriaiClient", 
+    "EuriaiEmbedding"
+]
+
+
+def check_optional_dependency(package_name: str, integration_name: str, install_extra: str = None) -> bool:
+    """
+    Check if an optional dependency is installed and provide helpful installation instructions.
+    
+    Args:
+        package_name: The actual package name to import
+        integration_name: The friendly name for the integration
+        install_extra: The extras_require key for pip install euriai[extra]
+    
+    Returns:
+        bool: True if package is available, False otherwise
+        
+    Raises:
+        ImportError: With helpful installation instructions
+    """
+    try:
+        __import__(package_name)
+        return True
+    except ImportError:
+        extra_option = f"euriai[{install_extra}]" if install_extra else f"euriai[{integration_name.lower()}]"
+        
+        error_msg = (
+            f"{integration_name} is not installed. Please install it using one of these methods:\n\n"
+            f"Option 1 (Recommended): Install with euriai extras:\n"
+            f"  pip install {extra_option}\n\n"
+            f"Option 2: Install {integration_name} directly:\n"
+            f"  pip install {package_name}\n\n"
+            f"Option 3: Install all euriai integrations:\n"
+            f"  pip install euriai[all]\n"
+        )
+        
+        raise ImportError(error_msg)
+
+
+def install_optional_dependency(package_name: str, integration_name: str, install_extra: str = None) -> bool:
+    """
+    Attempt to automatically install an optional dependency (USE WITH CAUTION).
+    
+    This function is provided for convenience but automatic installation can be risky.
+    It's generally better to install dependencies manually.
+    
+    Args:
+        package_name: The actual package name to install
+        integration_name: The friendly name for the integration  
+        install_extra: The extras_require key for pip install euriai[extra]
+    
+    Returns:
+        bool: True if installation succeeded, False otherwise
+    """
+    import subprocess
+    import sys
+    
+    try:
+        # Try to import first
+        __import__(package_name)
+        print(f"✓ {integration_name} is already installed")
+        return True
+    except ImportError:
+        pass
+    
+    # Ask user for confirmation
+    extra_option = f"euriai[{install_extra}]" if install_extra else f"euriai[{integration_name.lower()}]"
+    
+    print(f"🔍 {integration_name} is not installed.")
+    print(f"📦 Recommended installation: pip install {extra_option}")
+    
+    response = input(f"Would you like to automatically install {package_name}? (y/N): ").lower()
+    
+    if response in ['y', 'yes']:
+        try:
+            print(f"📥 Installing {package_name}...")
+            subprocess.check_call([sys.executable, "-m", "pip", "install", package_name])
+            print(f"✅ {integration_name} installed successfully!")
+            return True
+        except subprocess.CalledProcessError as e:
+            print(f"❌ Failed to install {package_name}: {e}")
+            print(f"💡 Try manually: pip install {extra_option}")
+            return False
+    else:
+        print(f"💡 To install manually run: pip install {extra_option}")
+        return False
+
+
+# Optional integrations with lazy loading
+def _lazy_import_with_check(module_name: str, package_name: str, integration_name: str, install_extra: str = None):
+    """Lazy import with automatic dependency checking."""
+    def _import():
+        check_optional_dependency(package_name, integration_name, install_extra)
+        from importlib import import_module
+        return import_module(f"euriai.{module_name}")
+    return _import
+
+# Lazy imports for optional integrations
+langchain = _lazy_import_with_check("langchain", "langchain-core", "LangChain", "langchain")
+crewai = _lazy_import_with_check("crewai", "crewai", "CrewAI")
+autogen = _lazy_import_with_check("autogen", "pyautogen", "AutoGen")
+smolagents = _lazy_import_with_check("smolagents", "smolagents", "SmolAgents")
+langgraph = _lazy_import_with_check("langgraph", "langgraph", "LangGraph")
+llamaindex = _lazy_import_with_check("llamaindex", "llama-index", "LlamaIndex", "llama-index")

euriai/autogen.py

@@ -198,7 +198,8 @@ class EuriaiAutoGen:
             default_model: Default model to use
         """
         if autogen is None:
-            raise ImportError("AutoGen is not installed. Please install with `pip install pyautogen`.")
+            from . import check_optional_dependency
+            check_optional_dependency("pyautogen", "AutoGen", "autogen")
         
         self.api_key = api_key
         self.default_model = default_model

euriai/crewai.py

@@ -17,7 +17,8 @@ except ImportError:
     class Task:
         pass
     class Process:
-        pass
+        sequential = "sequential"
+        parallel = "parallel"
     class LLM:
         pass
 

euriai/euri_embed.py

@@ -34,13 +34,29 @@ class EuriaiLlamaIndexEmbedding(BaseEmbedding):
         response.raise_for_status()
         return [np.array(obj["embedding"]).tolist() for obj in response.json()["data"]]
 
+    # Abstract methods required by BaseEmbedding (with underscore prefixes)
+    def _get_text_embedding(self, text: str) -> List[float]:
+        """Get embedding for a single text. Required abstract method."""
+        return self._post_embedding([text])[0]
+
+    def _get_query_embedding(self, query: str) -> List[float]:
+        """Get embedding for a query string. Required abstract method."""
+        return self._get_text_embedding(query)
+        
+    async def _aget_query_embedding(self, query: str) -> List[float]:
+        """Async version of get_query_embedding. Required abstract method."""
+        # For now, we don't support async, so we'll use the sync version
+        # In a real implementation, you'd want to use aiohttp or similar
+        return self._get_query_embedding(query)
+
+    # Public methods for backward compatibility
     def get_text_embedding(self, text: str) -> List[float]:
         """Get embedding for a single text."""
-        return self._post_embedding([text])[0]
+        return self._get_text_embedding(text)
 
     def get_query_embedding(self, query: str) -> List[float]:
         """Get embedding for a query string."""
-        return self.get_text_embedding(query)
+        return self._get_query_embedding(query)
         
     def get_text_embeddings(self, texts: List[str]) -> List[List[float]]:
         """Get embeddings for multiple texts."""
@@ -48,5 +64,4 @@ class EuriaiLlamaIndexEmbedding(BaseEmbedding):
         
     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")
+        return await self._aget_query_embedding(query)

euriai-1.0.5.dist-info/METADATA

@@ -0,0 +1,251 @@
+Metadata-Version: 2.4
+Name: euriai
+Version: 1.0.5
+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"
+Provides-Extra: all
+Requires-Dist: langchain-core; extra == "all"
+Requires-Dist: langchain; extra == "all"
+Requires-Dist: llama-index>=0.10.0; extra == "all"
+Requires-Dist: langgraph; extra == "all"
+Requires-Dist: smolagents; extra == "all"
+Requires-Dist: crewai; extra == "all"
+Requires-Dist: pyautogen; extra == "all"
+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
+
+# Euri AI Python SDK
+
+A comprehensive Python SDK for the Euri AI API with integrations for popular AI frameworks.
+
+## Installation
+
+### Basic Installation
+```bash
+pip install euriai
+```
+
+### With Optional Integrations
+```bash
+# Install specific integrations
+pip install euriai[autogen]    # AutoGen integration
+pip install euriai[crewai]     # CrewAI integration  
+pip install euriai[langchain]  # LangChain integration
+pip install euriai[smolagents] # SmolAgents integration
+pip install euriai[langgraph]  # LangGraph integration
+pip install euriai[llama-index] # LlamaIndex integration
+
+# Install all integrations
+pip install euriai[all]
+```
+
+## Quick Start
+
+### Basic Usage
+```python
+from euriai import EuriaiClient
+
+# Initialize client
+client = EuriaiClient(
+    api_key="your-euri-api-key",
+    model="gpt-4.1-nano"
+)
+
+# Generate completion
+response = client.generate_completion(
+    prompt="What is artificial intelligence?",
+    temperature=0.7,
+    max_tokens=1000
+)
+
+print(response["choices"][0]["message"]["content"])
+```
+
+### Framework Integrations
+
+The SDK provides seamless integrations with popular AI frameworks. Each integration is optional and can be installed separately.
+
+#### AutoGen Integration
+```python
+# This will automatically check if AutoGen is installed
+# and provide helpful installation instructions if not
+from euriai.autogen import EuriaiAutoGen
+
+autogen = EuriaiAutoGen(
+    api_key="your-euri-api-key",
+    default_model="gpt-4.1-nano"
+)
+```
+
+#### CrewAI Integration
+```python
+from euriai.crewai import EuriaiCrewAI
+
+crew = EuriaiCrewAI(
+    api_key="your-euri-api-key",
+    default_model="gpt-4.1-nano"
+)
+```
+
+#### LangChain Integration
+```python
+from euriai.langchain import EuriaiChatModel
+
+chat_model = EuriaiChatModel(
+    api_key="your-euri-api-key",
+    model="gpt-4.1-nano"
+)
+```
+
+### Handling Optional Dependencies
+
+If you try to use an integration without installing its dependencies, you'll get helpful error messages:
+
+```python
+try:
+    from euriai.autogen import EuriaiAutoGen
+except ImportError as e:
+    print(e)
+    # This will show:
+    # AutoGen is not installed. Please install it using one of these methods:
+    # 
+    # Option 1 (Recommended): Install with euriai extras:
+    #   pip install euriai[autogen]
+    # 
+    # Option 2: Install AutoGen directly:
+    #   pip install pyautogen
+    # 
+    # Option 3: Install all euriai integrations:
+    #   pip install euriai[all]
+```
+
+### Semi-Automatic Installation (Optional)
+
+For convenience, you can use the helper function to prompt for automatic installation:
+
+```python
+from euriai import install_optional_dependency
+
+# This will ask user permission before installing
+if install_optional_dependency("pyautogen", "AutoGen", "autogen"):
+    from euriai.autogen import EuriaiAutoGen
+    # Now you can use AutoGen integration
+```
+
+## Available Models
+
+- `gpt-4.1-nano` - Fast and efficient model
+- `gpt-4.1-mini` - Balanced performance model  
+- `gemini-2.5-flash` - Google's Gemini model
+- And more...
+
+## Framework Support
+
+| Framework | Installation | Description |
+|-----------|-------------|-------------|
+| **AutoGen** | `pip install euriai[autogen]` | Multi-agent conversation framework |
+| **CrewAI** | `pip install euriai[crewai]` | Role-playing AI agent framework |
+| **LangChain** | `pip install euriai[langchain]` | Building applications with LLMs |
+| **LangGraph** | `pip install euriai[langgraph]` | Building stateful, multi-actor applications |
+| **SmolAgents** | `pip install euriai[smolagents]` | Minimalist agent framework |
+| **LlamaIndex** | `pip install euriai[llama-index]` | Data framework for LLM applications |
+
+## Examples
+
+### AutoGen Multi-Agent Chat
+```python
+from euriai.autogen import EuriaiAutoGen
+
+autogen = EuriaiAutoGen(api_key="your-api-key")
+
+assistant = autogen.create_assistant_agent(
+    name="Assistant",
+    model="gpt-4.1-nano"
+)
+
+user_proxy = autogen.create_user_proxy_agent(
+    name="User",
+    human_input_mode="NEVER"
+)
+
+result = autogen.run_chat(
+    agent1=user_proxy,
+    agent2=assistant,
+    message="Explain quantum computing",
+    max_turns=3
+)
+```
+
+### CrewAI Workflow
+```python
+from euriai.crewai import EuriaiCrewAI
+
+crew = EuriaiCrewAI(api_key="your-api-key")
+
+crew.add_agent("researcher", {
+    "role": "Researcher",
+    "goal": "Research {topic}",
+    "backstory": "Expert researcher with analytical skills",
+    "model": "gpt-4.1-nano"
+})
+
+crew.add_task("research_task", {
+    "description": "Research the given topic",
+    "expected_output": "Comprehensive research report",
+    "agent": "researcher"
+})
+
+result = crew.run(inputs={"topic": "AI in Healthcare"})
+```
+
+## API Reference
+
+For detailed API documentation, visit: [https://euron.one/euri](https://euron.one/euri)
+
+## Support
+
+- **Documentation**: [https://docs.euron.one](https://euron.one/euri)
+- **GitHub**: [https://github.com/euri-ai/euriai-python-sdk](https://github.com/euri-ai/euriai-python-sdk)
+- **Email**: tech@euron.one
+
+## License
+
+MIT License - see LICENSE file for details.

{euriai-1.0.3.dist-info → euriai-1.0.5.dist-info}/RECORD

@@ -1,18 +1,18 @@
-euriai/__init__.py,sha256=WE4zl0HNxDm4zwR3d0uRyjl3fjcD_pccKvPsbtuDysw,916
-euriai/autogen.py,sha256=4YAHrY65YYOKVsBjQa9G8pr-_Xxss1uR08qLAFzo7Rk,16023
+euriai/__init__.py,sha256=P1kgfg-wUrzUOMPu5hIuwogi75xW69S5GJe2_ELvo8s,4541
+euriai/autogen.py,sha256=a_uKUn1FTxlFx7d7LwFnsM6TsdGbdecYxwujIp6xU0w,16044
 euriai/cli.py,sha256=hF1wiiL2QQSfWf8WlLQyNVDBd4YkbiwmMSoPxVbyPTM,3290
 euriai/client.py,sha256=L-o6hv9N3md-l-hz-kz5nYVaaZqnrREZlo_0jguhF7E,4066
-euriai/crewai.py,sha256=eeDfZQC9LtEePSnaj94DA0Kcb8Ayq0Gn_eDSQwbcMBU,7543
+euriai/crewai.py,sha256=nfMMOOhKiCIc2v42nj2Zf9rP0U5m4GrfK_6zkXL77gw,7594
 euriai/embedding.py,sha256=uP66Ph1k9Ou6J5RAkztJxlfyj0S0MESOvZ4ulhnVo-o,1270
 euriai/euri_chat.py,sha256=DEAiet1ReRwB4ljkPYaTl1Nb5uc20-JF-3PQjGQZXk4,3567
-euriai/euri_embed.py,sha256=VE-RLUb5bYnEFA_dxFkj2c3Jr_SYyJKPmFOzsDOR0Ys,2137
+euriai/euri_embed.py,sha256=g7zs1G-ZBDJjOGJtkkfIcV4LPtRcm9wpVWmrfMGn5EM,2919
 euriai/langchain.py,sha256=gVF9eh21RC1WtDn7SQoEREUDqOObm5IRx6BFZtB5xcc,34968
 euriai/langgraph.py,sha256=sw9e-PnfwAwmp_tUCnAGIUB78GyJsMkAzxOGvFUafiM,34128
 euriai/llamaindex.py,sha256=c-ujod2bjL6QIvfAyuIxm1SvSCS00URFElYybKQ5Ew0,26551
 euriai/n8n.py,sha256=hjkckqyW_hZNL78UkBCof1WvKCKCIjwdvZdAgx6NrB8,3764
 euriai/smolagents.py,sha256=xlixGx2IWzAPTpSJGsYIK2L-SHGY9Mw1-8GbwVsEYtU,28507
-euriai-1.0.3.dist-info/METADATA,sha256=VL-iLUQt3qiPi5EMJg2_-19Z7m4zO74RvDtJ3CgwVu0,6881
-euriai-1.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-euriai-1.0.3.dist-info/entry_points.txt,sha256=9OkET8KIGcsjQn8UlnpPKRT75s2KW34jq1__1SXtpMA,43
-euriai-1.0.3.dist-info/top_level.txt,sha256=TG1htJ8cuD62MXn-NJ7DVF21QHY16w6M_QgfF_Er_EQ,7
-euriai-1.0.3.dist-info/RECORD,,
+euriai-1.0.5.dist-info/METADATA,sha256=CJxhIdp9ydjeH4QtwA8PTd-abReVJ4eqt94diMDNLlU,6806
+euriai-1.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+euriai-1.0.5.dist-info/entry_points.txt,sha256=9OkET8KIGcsjQn8UlnpPKRT75s2KW34jq1__1SXtpMA,43
+euriai-1.0.5.dist-info/top_level.txt,sha256=TG1htJ8cuD62MXn-NJ7DVF21QHY16w6M_QgfF_Er_EQ,7
+euriai-1.0.5.dist-info/RECORD,,

euriai-1.0.3.dist-info/METADATA

@@ -1,282 +0,0 @@
-Metadata-Version: 2.4
-Name: euriai
-Version: 1.0.3
-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.