cocoindex 0.1.29__tar.gz → 0.1.30__tar.gz

{cocoindex-0.1.29 → cocoindex-0.1.30}/.env.lib_debug

@@ -1,4 +1,4 @@
 export RUST_LOG=warn,cocoindex_engine=trace,tower_http=trace
 export RUST_BACKTRACE=1
 
-export COCOINDEX_SERVER_CORS_ORIGIN=http://localhost:3000
+export COCOINDEX_SERVER_CORS_ORIGINS=http://localhost:3000,https://cocoindex.io

{cocoindex-0.1.29 → cocoindex-0.1.30}/Cargo.lock

@@ -533,7 +533,7 @@ dependencies = [
 
 [[package]]
 name = "cocoindex"
-version = "0.1.29"
+version = "0.1.30"
 dependencies = [
  "anyhow",
  "async-openai",

{cocoindex-0.1.29 → cocoindex-0.1.30}/Cargo.toml

@@ -2,7 +2,7 @@
 name = "cocoindex"
 # Version used for local development is always higher than others to take precedence.
 # Will be overridden for specific release versions.
-version = "0.1.29"
+version = "0.1.30"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

{cocoindex-0.1.29 → cocoindex-0.1.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cocoindex
-Version: 0.1.29
+Version: 0.1.30
 Requires-Dist: sentence-transformers>=3.3.1
 Requires-Dist: click>=8.1.8
 Requires-Dist: rich>=14.0.0

cocoindex-0.1.30/examples/docs_to_knowledge_graph/README.md

@@ -0,0 +1,80 @@
+# Build Real-Time Knowledge Graph For Documents with LLM
+
+We will process a list of documents and use LLM to extract relationships between the concepts in each document. 
+We will generate two kinds of relationships:
+
+1. Relationships between subjects and objects. E.g., "CocoIndex supports Incremental Processing"
+2. Mentions of entities in a document. E.g., "core/basics.mdx" mentions `CocoIndex` and `Incremental Processing`.
+
+You can find a step by step blog for this project [here](https://cocoindex.io/blogs/knowledge-graph-for-docs)
+
+Please drop [Cocoindex on Github](https://github.com/cocoindex-io/cocoindex) a star to support us if you like our work. Thank you so much with a warm coconut hug 🥥🤗. [![GitHub](https://img.shields.io/github/stars/cocoindex-io/cocoindex?color=5B5BD6)](https://github.com/cocoindex-io/cocoindex)
+
+![example-explanation](https://github.com/user-attachments/assets/07ddbd60-106f-427f-b7cc-16b73b142d27)
+
+
+## Prerequisite
+*   [Install Postgres](https://cocoindex.io/docs/getting_started/installation#-install-postgres) if you don't have one.
+*   [Install Neo4j](https://cocoindex.io/docs/ops/storages#neo4j) if you don't have one.
+*   [Configure your OpenAI API key](https://cocoindex.io/docs/ai/llm#openai).
+
+## Documentation
+You can read the official CocoIndex Documentation for Property Graph Targets [here](https://cocoindex.io/docs/ops/storages#property-graph-targets).
+
+## Run
+
+### Build the index
+
+Install dependencies:
+
+```bash
+pip install -e .
+```
+
+Setup:
+
+```bash
+python main.py cocoindex setup
+```
+
+Update index:
+
+```bash
+python main.py cocoindex update
+```
+
+### Browse the knowledge graph
+
+After the knowledge graph is build, you can explore the knowledge graph you built in Neo4j Browser.
+
+For the dev enviroment, you can connect neo4j browser using credentials:
+- username: `neo4j`
+- password: `cocoindex`
+which is pre-configured in the our docker compose [config.yaml](https://raw.githubusercontent.com/cocoindex-io/cocoindex/refs/heads/main/dev/neo4j.yaml).
+
+You can open it at [http://localhost:7474](http://localhost:7474), and run the following Cypher query to get all relationships:
+
+```cypher
+MATCH p=()-->() RETURN p
+```
+<img width="1366" alt="neo4j-for-coco-docs" src="https://github.com/user-attachments/assets/3c8b6329-6fee-4533-9480-571399b57e57" />
+
+
+
+## CocoInsight 
+I used CocoInsight (Free beta now) to troubleshoot the index generation and understand the data lineage of the pipeline. 
+It just connects to your local CocoIndex server, with Zero pipeline data retention. Run following command to start CocoInsight:
+
+```bash
+python3 main.py cocoindex server -c https://cocoindex.io
+```
+
+And then open the url https://cocoindex.io/cocoinsight. 
+
+```
+python main.py cocoindex server -c https://cocoindex.io
+```
+
+<img width="1430" alt="cocoinsight" src="https://github.com/user-attachments/assets/d5ada581-cceb-42bf-a949-132df674f3dd" />
+
+

{cocoindex-0.1.29 → cocoindex-0.1.30}/python/cocoindex/auth_registry.py

@@ -3,16 +3,19 @@ Auth registry is used to register and reference auth entries.
 """
 
 from dataclasses import dataclass
+from typing import Generic, TypeVar
 
 from . import _engine
 from .convert import dump_engine_object
 
+T = TypeVar("T")
+
 @dataclass
-class AuthEntryReference:
+class AuthEntryReference(Generic[T]):
     """Reference an auth entry by its key."""
     key: str
 
-def add_auth_entry(key: str, value) -> AuthEntryReference:
+def add_auth_entry(key: str, value: T) -> AuthEntryReference[T]:
     """Add an auth entry to the registry. Returns its reference."""
     _engine.add_auth_entry(key, dump_engine_object(value))
     return AuthEntryReference(key)

{cocoindex-0.1.29 → cocoindex-0.1.30}/python/cocoindex/cli.py

@@ -1,9 +1,9 @@
-import asyncio
 import click
 import datetime
+
 from rich.console import Console
 
-from . import flow, lib
+from . import flow, lib, setting
 from .setup import sync_setup, drop_setup, flow_names_with_setup, apply_setup_changes
 from .runtime import execution_context
 
@@ -21,7 +21,7 @@ def ls(show_all: bool):
     """
     List all flows.
     """
-    current_flow_names = [fl.name for fl in flow.flows()]
+    current_flow_names = flow.flow_names()
     persisted_flow_names = flow_names_with_setup()
     remaining_persisted_flow_names = set(persisted_flow_names)
 
@@ -58,9 +58,9 @@ def show(flow_name: str | None, color: bool):
     """
     Show the flow spec in a readable format with colored output.
     """
-    flow = _flow_by_name(flow_name)
+    fl = _flow_by_name(flow_name)
     console = Console(no_color=not color)
-    console.print(flow._render_text())
+    console.print(fl._render_text())
 
 @cli.command()
 def setup():
@@ -149,32 +149,59 @@ def evaluate(flow_name: str | None, output_dir: str | None, cache: bool = True):
     options = flow.EvaluateAndDumpOptions(output_dir=output_dir, use_cache=cache)
     fl.evaluate_and_dump(options)
 
-_default_server_settings = lib.ServerSettings.from_env()
+# Create ServerSettings lazily upon first call, as environment variables may be loaded from files, etc.
+COCOINDEX_HOST = 'https://cocoindex.io'
 
 @cli.command()
 @click.option(
-    "-a", "--address", type=str, default=_default_server_settings.address,
-    help="The address to bind the server to, in the format of IP:PORT.")
+    "-a", "--address", type=str,
+    help="The address to bind the server to, in the format of IP:PORT. "
+         "If unspecified, the address specified in COCOINDEX_SERVER_ADDRESS will be used.")
+@click.option(
+    "-c", "--cors-origin", type=str,
+    help="The origins of the clients (e.g. CocoInsight UI) to allow CORS from. "
+         "Multiple origins can be specified as a comma-separated list. "
+         "e.g. `https://cocoindex.io,http://localhost:3000`. "
+         "Origins specified in COCOINDEX_SERVER_CORS_ORIGINS will also be included.")
+@click.option(
+    "-ci", "--cors-cocoindex", is_flag=True, show_default=True, default=False,
+    help=f"Allow {COCOINDEX_HOST} to access the server.")
 @click.option(
-    "-c", "--cors-origin", type=str, default=_default_server_settings.cors_origin,
-    help="The origin of the client (e.g. CocoInsight UI) to allow CORS from. "
-         "e.g. `http://cocoindex.io` if you want to allow CocoInsight to access the server.")
+    "-cl", "--cors-local", type=int,
+    help="Allow http://localhost:<port> to access the server.")
 @click.option(
     "-L", "--live-update", is_flag=True, show_default=True, default=False,
     help="Continuously watch changes from data sources and apply to the target index.")
 @click.option(
     "-q", "--quiet", is_flag=True, show_default=True, default=False,
     help="Avoid printing anything to the standard output, e.g. statistics.")
-def server(address: str, live_update: bool, quiet: bool, cors_origin: str | None):
+def server(address: str | None, live_update: bool, quiet: bool, cors_origin: str | None,
+           cors_cocoindex: bool, cors_local: int | None):
     """
     Start a HTTP server providing REST APIs.
 
     It will allow tools like CocoInsight to access the server.
     """
-    lib.start_server(lib.ServerSettings(address=address, cors_origin=cors_origin))
+    server_settings = setting.ServerSettings.from_env()
+    cors_origins: set[str] = set(server_settings.cors_origins or [])
+    if cors_origin is not None:
+        cors_origins.update(setting.ServerSettings.parse_cors_origins(cors_origin))
+    if cors_cocoindex:
+        cors_origins.add(COCOINDEX_HOST)
+    if cors_local is not None:
+        cors_origins.add(f"http://localhost:{cors_local}")
+    server_settings.cors_origins = list(cors_origins)
+
+    if address is not None:
+        server_settings.address = address
+
+    lib.start_server(server_settings)
+
     if live_update:
         options = flow.FlowLiveUpdaterOptions(live_mode=True, print_stats=not quiet)
         execution_context.run(flow.update_all_flows(options))
+    if COCOINDEX_HOST in cors_origins:
+        click.echo(f"Open CocoInsight at: {COCOINDEX_HOST}/cocoinsight")
     input("Press Enter to stop...")
 
 

{cocoindex-0.1.29 → cocoindex-0.1.30}/python/cocoindex/functions.py

@@ -1,10 +1,13 @@
 """All builtin functions."""
-from typing import Annotated, Any
+from typing import Annotated, Any, TYPE_CHECKING
 
-import sentence_transformers
 from .typing import Float32, Vector, TypeAttr
 from . import op, llm
 
+# Libraries that are heavy to import. Lazily import them later.
+if TYPE_CHECKING:
+    import sentence_transformers
+
 class ParseJson(op.FunctionSpec):
     """Parse a text into a JSON object."""
 
@@ -35,9 +38,10 @@ class SentenceTransformerEmbedExecutor:
     """Executor for SentenceTransformerEmbed."""
 
     spec: SentenceTransformerEmbed
-    _model: sentence_transformers.SentenceTransformer
+    _model: "sentence_transformers.SentenceTransformer"
 
     def analyze(self, text):
+        import sentence_transformers # pylint: disable=import-outside-toplevel
         args = self.spec.args or {}
         self._model = sentence_transformers.SentenceTransformer(self.spec.model, **args)
         dim = self._model.get_sentence_embedding_dimension()

{cocoindex-0.1.29 → cocoindex-0.1.30}/python/cocoindex/lib.py

@@ -1,76 +1,23 @@
 """
 Library level functions and states.
 """
-import os
 import sys
 import functools
 import inspect
 
-from typing import Callable, Self
-from dataclasses import dataclass
+from typing import Callable
 
 from . import _engine
-from . import flow, query, cli
+from . import flow, query, cli, setting
 from .convert import dump_engine_object
 
 
-def _load_field(target: dict[str, str], name: str, env_name: str, required: bool = False):
-    value = os.getenv(env_name)
-    if value is None:
-        if required:
-            raise ValueError(f"{env_name} is not set")
-    else:
-        target[name] = value
-
-@dataclass
-class DatabaseConnectionSpec:
-    url: str
-    user: str | None = None
-    password: str | None = None
-
-@dataclass
-class Settings:
-    """Settings for the cocoindex library."""
-    database: DatabaseConnectionSpec
-
-    @classmethod
-    def from_env(cls) -> Self:
-        """Load settings from environment variables."""
-
-        db_kwargs: dict[str, str] = dict()
-        _load_field(db_kwargs, "url", "COCOINDEX_DATABASE_URL", required=True)
-        _load_field(db_kwargs, "user", "COCOINDEX_DATABASE_USER")
-        _load_field(db_kwargs, "password", "COCOINDEX_DATABASE_PASSWORD")
-        database = DatabaseConnectionSpec(**db_kwargs)
-        return cls(database=database)
-
-
-def init(settings: Settings):
+def init(settings: setting.Settings):
     """Initialize the cocoindex library."""
     _engine.init(dump_engine_object(settings))
 
-@dataclass
-class ServerSettings:
-    """Settings for the cocoindex server."""
-
-    # The address to bind the server to.
-    address: str = "127.0.0.1:8080"
-
-    # The origin of the client (e.g. CocoInsight UI) to allow CORS from.
-    cors_origin: str | None = None
-
-    @classmethod
-    def from_env(cls) -> Self:
-        """Load settings from environment variables."""
-
-        kwargs: dict[str, str] = dict()
-        _load_field(kwargs, "address", "COCOINDEX_SERVER_ADDRESS")
-        _load_field(kwargs, "cors_origin", "COCOINDEX_SERVER_CORS_ORIGIN")
-
-        return cls(**kwargs)
-
 
-def start_server(settings: ServerSettings):
+def start_server(settings: setting.ServerSettings):
     """Start the cocoindex server."""
     flow.ensure_all_flows_built()
     query.ensure_all_handlers_built()
@@ -81,7 +28,7 @@ def stop():
     _engine.stop()
 
 def main_fn(
-        settings: Settings | None = None,
+        settings: setting.Settings | None = None,
         cocoindex_cmd: str = 'cocoindex',
         ) -> Callable[[Callable], Callable]:
     """
@@ -92,7 +39,7 @@ def main_fn(
     """
 
     def _pre_init() -> None:
-        effective_settings = settings or Settings.from_env()
+        effective_settings = settings or setting.Settings.from_env()
         init(effective_settings)
 
     def _should_run_cli() -> bool:

{cocoindex-0.1.29 → cocoindex-0.1.30}/python/cocoindex/op.py

@@ -5,10 +5,10 @@ import asyncio
 import dataclasses
 import inspect
 
-from typing import get_type_hints, Protocol, Any, Callable, Awaitable, dataclass_transform
+from typing import Protocol, Any, Callable, Awaitable, dataclass_transform
 from enum import Enum
 
-from .typing import encode_enriched_type
+from .typing import encode_enriched_type, resolve_forward_ref
 from .convert import encode_engine_value, make_engine_value_decoder
 from . import _engine
 
@@ -214,10 +214,11 @@ def executor_class(**args) -> Callable[[type], type]:
         """
         Decorate a class to provide an executor for an op.
         """
-        type_hints = get_type_hints(cls)
+        # Use `__annotations__` instead of `get_type_hints`, to avoid resolving forward references.
+        type_hints = cls.__annotations__
         if 'spec' not in type_hints:
             raise TypeError("Expect a `spec` field with type hint")
-        spec_cls = type_hints['spec']
+        spec_cls = resolve_forward_ref(type_hints['spec'])
         sig = inspect.signature(cls.__call__)
         return _register_op_factory(
             category=spec_cls._op_category,

cocoindex-0.1.30/python/cocoindex/setting.py

@@ -0,0 +1,77 @@
+"""
+Data types for settings of the cocoindex library.
+"""
+import os
+
+from typing import Callable, Self, Any, overload
+from dataclasses import dataclass
+
+
+@dataclass
+class DatabaseConnectionSpec:
+    """
+    Connection spec for relational database.
+    Used by both internal and target storage.
+    """
+    url: str
+    user: str | None = None
+    password: str | None = None
+
+def _load_field(target: dict[str, Any], name: str, env_name: str, required: bool = False,
+                parse: Callable[[str], Any] | None = None):
+    value = os.getenv(env_name)
+    if value is None:
+        if required:
+            raise ValueError(f"{env_name} is not set")
+    else:
+        target[name] = value if parse is None else parse(value)
+
+@dataclass
+class Settings:
+    """Settings for the cocoindex library."""
+    database: DatabaseConnectionSpec
+
+    @classmethod
+    def from_env(cls) -> Self:
+        """Load settings from environment variables."""
+
+        db_kwargs: dict[str, str] = dict()
+        _load_field(db_kwargs, "url", "COCOINDEX_DATABASE_URL", required=True)
+        _load_field(db_kwargs, "user", "COCOINDEX_DATABASE_USER")
+        _load_field(db_kwargs, "password", "COCOINDEX_DATABASE_PASSWORD")
+        database = DatabaseConnectionSpec(**db_kwargs)
+        return cls(database=database)
+
+@dataclass
+class ServerSettings:
+    """Settings for the cocoindex server."""
+
+    # The address to bind the server to.
+    address: str = "127.0.0.1:8080"
+
+    # The origins of the clients (e.g. CocoInsight UI) to allow CORS from.
+    cors_origins: list[str] | None = None
+
+    @classmethod
+    def from_env(cls) -> Self:
+        """Load settings from environment variables."""
+        kwargs: dict[str, Any] = dict()
+        _load_field(kwargs, "address", "COCOINDEX_SERVER_ADDRESS")
+        _load_field(kwargs, "cors_origins", "COCOINDEX_SERVER_CORS_ORIGINS",
+                    parse=ServerSettings.parse_cors_origins)
+        return cls(**kwargs)
+
+    @overload
+    @staticmethod
+    def parse_cors_origins(s: str) -> list[str]: ...
+
+    @overload
+    @staticmethod
+    def parse_cors_origins(s: str | None) -> list[str] | None: ...
+
+    @staticmethod
+    def parse_cors_origins(s):
+        """
+        Parse the CORS origins from a string.
+        """
+        return [o for e in s.split(",") if (o := e.strip()) != ""] if s is not None else None

{cocoindex-0.1.29 → cocoindex-0.1.30}/python/cocoindex/storages.py

@@ -5,11 +5,11 @@ from typing import Sequence
 from . import op
 from . import index
 from .auth_registry import AuthEntryReference
+from .setting import DatabaseConnectionSpec
 
 class Postgres(op.StorageSpec):
     """Storage powered by Postgres and pgvector."""
-
-    database: AuthEntryReference | None = None
+    database: AuthEntryReference[DatabaseConnectionSpec] | None = None
     table_name: str | None = None
 
 @dataclass
@@ -72,15 +72,14 @@ NodeReferenceMapping = NodeFromFields
 
 class Neo4j(op.StorageSpec):
     """Graph storage powered by Neo4j."""
-
-    connection: AuthEntryReference
+    connection: AuthEntryReference[Neo4jConnection]
     mapping: Nodes | Relationships
 
 class Neo4jDeclaration(op.DeclarationSpec):
     """Declarations for Neo4j."""
 
     kind = "Neo4j"
-    connection: AuthEntryReference
+    connection: AuthEntryReference[Neo4jConnection]
     nodes_label: str
     primary_key_fields: Sequence[str]
     vector_indexes: Sequence[index.VectorIndexDef] = ()

{cocoindex-0.1.29 → cocoindex-0.1.30}/python/cocoindex/typing.py

@@ -245,3 +245,8 @@ def encode_enriched_type(t) -> dict[str, Any] | None:
         return None
 
     return encode_enriched_type_info(analyze_type_info(t))
+
+def resolve_forward_ref(t):
+    if t is str:
+        return eval(t) # pylint: disable=eval-used
+    return t

{cocoindex-0.1.29 → cocoindex-0.1.30}/src/server.rs

@@ -1,10 +1,7 @@
-use crate::{lib_context::LibContext, service};
+use crate::prelude::*;
 
-use anyhow::Result;
+use crate::{lib_context::LibContext, service};
 use axum::{routing, Router};
-use futures::{future::BoxFuture, FutureExt};
-use serde::Deserialize;
-use std::sync::Arc;
 use tower::ServiceBuilder;
 use tower_http::{
     cors::{AllowOrigin, CorsLayer},
@@ -14,7 +11,8 @@ use tower_http::{
 #[derive(Deserialize, Debug)]
 pub struct ServerSettings {
     pub address: String,
-    pub cors_origin: Option<String>,
+    #[serde(default)]
+    pub cors_origins: Vec<String>,
 }
 
 /// Initialize the server and return a future that will actually handle requests.
@@ -23,9 +21,15 @@ pub async fn init_server(
     settings: ServerSettings,
 ) -> Result<BoxFuture<'static, ()>> {
     let mut cors = CorsLayer::default();
-    if let Some(ui_cors_origin) = &settings.cors_origin {
+    debug!("cors_origins: {:?}", settings.cors_origins);
+    if !settings.cors_origins.is_empty() {
+        let origins: Vec<_> = settings
+            .cors_origins
+            .iter()
+            .map(|origin| origin.parse())
+            .collect::<Result<_, _>>()?;
         cors = cors
-            .allow_origin(AllowOrigin::exact(ui_cors_origin.parse()?))
+            .allow_origin(AllowOrigin::list(origins))
             .allow_methods([
                 axum::http::Method::GET,
                 axum::http::Method::POST,

{cocoindex-0.1.29 → cocoindex-0.1.30}/src/setup/driver.rs

@@ -215,11 +215,11 @@ fn group_resource_states<'a>(
             entry.existing.current = Some(current.clone());
         }
         if let Some(legacy_state_key) = &state.legacy_state_key {
-            if !entry
+            if entry
                 .existing
                 .legacy_state_key
                 .as_ref()
-                .map_or(false, |v| v == legacy_state_key)
+                .map_or(false, |v| v != legacy_state_key)
             {
                 warn!(
                     "inconsistent legacy key: {:?}, {:?}",

cocoindex-0.1.29/examples/docs_to_knowledge_graph/README.md

@@ -1,67 +0,0 @@
-# Build Knowledge Graph from Markdown Documents, with OpenAI, Neo4j and CocoIndex
-
-In this example, we
-
-*   Extract relationships from Markdown documents.
-*   Build a knowledge graph from the relationships.
-
-Please give [Cocoindex on Github](https://github.com/cocoindex-io/cocoindex) a star to support us if you like our work. Thank you so much with a warm coconut hug 🥥🤗. [![GitHub](https://img.shields.io/github/stars/cocoindex-io/cocoindex?color=5B5BD6)](https://github.com/cocoindex-io/cocoindex)
-
-## Prerequisite
-
-Before running the example, you need to:
-
-*   [Install Postgres](https://cocoindex.io/docs/getting_started/installation#-install-postgres) if you don't have one.
-*   [Install Neo4j](https://cocoindex.io/docs/ops/storages#neo4j) if you don't have one.
-*   Install / configure LLM API. In this example we use OpenAI. You need to [configure OpenAI API key](https://cocoindex.io/docs/ai/llm#openai) before running the example. Alternatively, you can also follow the comments in source code to switch to Ollama, which runs LLM model locally, and get it ready following [this guide](https://cocoindex.io/docs/ai/llm#ollama).
-
-## Run
-
-### Build the index
-
-Install dependencies:
-
-```bash
-pip install -e .
-```
-
-Setup:
-
-```bash
-python main.py cocoindex setup
-```
-
-Update index:
-
-```bash
-python main.py cocoindex update
-```
-
-### Browse the knowledge graph
-
-After the knowledge graph is build, you can explore the knowledge graph you built in Neo4j Browser.
-
-For the dev enviroment, you can connect neo4j browser using credentials:
-- username: `neo4j`
-- password: `cocoindex`
-which is pre-configured in the our docker compose [config.yaml](https://raw.githubusercontent.com/cocoindex-io/cocoindex/refs/heads/main/dev/neo4j.yaml).
-
-You can open it at [http://localhost:7474](http://localhost:7474), and run the following Cypher query to get all relationships:
-
-```cypher
-MATCH p=()-->() RETURN p
-```
-
-## CocoInsight 
-CocoInsight is a tool to help you understand your data pipeline and data index. CocoInsight is in Early Access now (Free) 😊 You found us! A quick 3 minute video tutorial about CocoInsight: [Watch on YouTube](https://youtu.be/ZnmyoHslBSc?si=pPLXWALztkA710r9).
-
-Run CocoInsight to understand your RAG data pipeline:
-
-```
-python main.py cocoindex server -c https://cocoindex.io
-```
-
-Then open the CocoInsight UI at [https://cocoindex.io/cocoinsight](https://cocoindex.io/cocoinsight). It connects to your local CocoIndex server with zero data retention.
-
-You can view the pipeline flow and the data preview in the CocoInsight UI:
-![CocoInsight UI](https://cocoindex.io/blogs/assets/images/cocoinsight-edd71690dcc35b6c5cf1cb31b51b6f6f.png)